development: refactored Deque

Author: Daniel Dahan

Sources/Algorithm+Array.swift

@@ -29,23 +29,39 @@
  */
 
 extension Array where Element: Equatable {
-	@discardableResult
+	/**
+     Removes a given Element from an Array if it exists.
+     - Parameter object: An Element.
+     - Returns: An optional Element if the removed
+     element exists.
+     */
+    @discardableResult
     mutating func remove(object: Element) -> Element? {
-		if let v: Int = index(of: object) {
-			return remove(at: v)
-		}
-		return nil
+        guard let v = index(of: object) else {
+            return nil
+        }
+        return remove(at: v)
 	}
 
+    /**
+     Removes a list of given Elements from an Array if
+     they exists.
+     - Parameter objects: A list of Elements.
+     */
     @discardableResult
 	mutating func remove(objects: Element...) {
 		remove(objects: objects)
 	}
 
+    /**
+     Removes an Array of given Elements from an Array if
+     they exists.
+     - Parameter objects: An Array of Elements.
+     */
     @discardableResult
 	mutating func remove(objects: [Element]) {
-        for x in objects {
-            remove(object: x)
+        objects.forEach {
+            self.remove(object: $0)
         }
 	}
 }
@@ -67,13 +83,13 @@ extension Array: ProbableType {
      */
     public func count<Element: Equatable>(of elements: [Element]) -> Int {
 		var c: Int = 0
-		for v in elements {
-			for x in self {
-				if v == x as! Element {
-					c += 1
-				}
-			}
-		}
+        for e in elements {
+            for x in self {
+                if e == x as? Element {
+                    c += 1
+                }
+            }
+        }
 		return c
 	}
 
@@ -92,29 +108,25 @@ extension Array: ProbableType {
      - Returns: A Double.
      */
     public func probability<Element: Equatable>(of elements: [Element]) -> Double {
-        guard 0 < count else {
-            return 0
-        }
-        
-        return Double(count(of: elements)) / Double(count)
+        return 0 < count ? Double(count(of: elements)) / Double(count) : 0
 	}
 
     /**
      A probability method that uses a block to determine the member state of a condition.
      - Parameter of elements: A list of Elements.
      - Returns: A Double.
      */
-    public func probability(of block: (Element) -> Bool) -> Double {
+    public func probability(of block: @escaping (Element) -> Bool) -> Double {
         guard 0 < count else {
             return 0
         }
 
-		var c: Int = 0
-		for x in self {
-			if block(x) {
-				c += 1
-			}
-		}
+        var c: Int = 0
+        for e in self {
+            if block(e) {
+                c += 1
+            }
+        }
 
 		return Double(c) / Double(count)
 	}

Sources/Algorithm+Set.swift

@@ -45,9 +45,9 @@ extension Set: ProbableType {
      */
     public func count<Element: Equatable>(of elements: [Element]) -> Int {
         var c: Int = 0
-        for v in elements {
+        for e in elements {
             for x in self {
-                if v == x as! Element {
+                if e == x as? Element {
                     c += 1
                 }
             }
@@ -70,26 +70,22 @@ extension Set: ProbableType {
      - Returns: A Double.
      */
     public func probability<Element: Equatable>(of elements: [Element]) -> Double {
-        guard 0 < count else {
-            return 0
-        }
-        
-        return Double(count(of: elements)) / Double(count)
+        return 0 < count ? Double(count(of: elements)) / Double(count) : 0
     }
 
     /**
      A probability method that uses a block to determine the member state of a condition.
      - Parameter of elements: A list of Elements.
      - Returns: A Double.
      */
-    public func probability(of block: (Element) -> Bool) -> Double {
+    public func probability(of block: @escaping (Element) -> Bool) -> Double {
         guard 0 < count else {
             return 0
         }
 
         var c: Int = 0
-        for x in self {
-            if block(x) {
+        for e in self {
+            if block(e) {
                 c += 1
             }
         }

Sources/Deque.swift

@@ -28,8 +28,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-public class Deque<Element>: CustomStringConvertible, Sequence {
-	public typealias Iterator = AnyIterator<Element?>
+public struct Deque<Element>: CustomStringConvertible, Sequence {
+	public typealias Iterator = AnyIterator<Element>
 
 	/**
 		:name:	list
@@ -107,7 +107,7 @@ public class Deque<Element>: CustomStringConvertible, Sequence {
 		:name:	insertAtFront
 		:description:	Insert a new element at the front of the Deque.
 	*/
-	public func insertAtFront(_ element: Element) {
+	mutating public func insert(atFront element: Element) {
 		list.insertAtFront(element)
 	}
 
@@ -117,15 +117,15 @@ public class Deque<Element>: CustomStringConvertible, Sequence {
 		and remove it.
 		- returns:	Element?
 	*/
-    public func removeAtFront() -> Element? {
+    mutating public func removeAtFront() -> Element? {
 		return list.removeAtFront()
 	}
 
 	/**
 		:name:	insertAtBack
 		:description:	Insert a new element at the back of the Deque.
 	*/
-	public func insertAtBack(_ element: Element) {
+	mutating public func insert(atBack element: Element) {
 		list.insertAtBack(element)
 	}
 
@@ -135,7 +135,7 @@ public class Deque<Element>: CustomStringConvertible, Sequence {
 		and remove it.
 		- returns:	Element?
 	*/
-	public func removeAtBack() -> Element? {
+	mutating public func removeAtBack() -> Element? {
 		return list.removeAtBack()
 	}
 
@@ -149,18 +149,18 @@ public class Deque<Element>: CustomStringConvertible, Sequence {
 }
 
 public func +<Element>(lhs: Deque<Element>, rhs: Deque<Element>) -> Deque<Element> {
-	let d: Deque<Element> = Deque<Element>()
+	var d = Deque<Element>()
 	for x in lhs {
-		d.insertAtBack(x!)
+        d.insert(atBack: x)
 	}
 	for x in rhs {
-		d.insertAtBack(x!)
+        d.insert(atBack: x)
 	}
 	return d
 }
 
-public func +=<Element>(lhs: Deque<Element>, rhs: Deque<Element>) {
+public func +=<Element>(lhs: inout Deque<Element>, rhs: Deque<Element>) {
 	for x in rhs {
-		lhs.insertAtBack(x!)
+        lhs.insert(atBack: x)
 	}
 }

Sources/DoublyLinkedList.swift

@@ -29,7 +29,7 @@
 */
 
 public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
-	public typealias Iterator = AnyIterator<Element?>
+	public typealias Iterator = AnyIterator<Element>
 
 	/**
 		:name:	head
@@ -68,7 +68,7 @@ public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
 	internal var internalDescription: String {
 		var output: String = "("
 		var c: Int = 0
-		var x: DoublyLinkedListNode<Element>? = head
+		var x = head
 		while nil !== x {
 			output += "\(x)"
 			c += 1
@@ -286,12 +286,12 @@ public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
 		if 0 == count {
 			return nil
 		}
-		let element: Element? = tail!.element
+		let element = tail?.element
 		count -= 1
 		if 0 == count {
 			reset()
 		} else {
-			tail = tail!.previous
+			tail = tail?.previous
 		}
 		return element
 	}
@@ -320,7 +320,7 @@ public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
 		if nil === current || head === current {
 			insertAtFront(element)
 		} else {
-			let z: DoublyLinkedListNode<Element> = DoublyLinkedListNode<Element>(next: current, previous: current!.previous,  element: element)
+			let z = DoublyLinkedListNode<Element>(next: current, previous: current!.previous,  element: element)
 			current!.previous?.next = z
 			current!.previous = z
 			count += 1
@@ -335,7 +335,7 @@ public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
 		if nil === current || tail === current {
 			insertAtBack(element)
 		} else {
-			let z: DoublyLinkedListNode<Element> = DoublyLinkedListNode<Element>(next: current!.next, previous: current,  element: element)
+			let z = DoublyLinkedListNode<Element>(next: current!.next, previous: current,  element: element)
 			current!.next?.previous = z
 			current!.next = z
 			count += 1
@@ -352,17 +352,17 @@ public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
 		if 1 >= count {
 			return removeAtFront()
 		} else {
-			let element: Element? = current!.element
-			current!.previous?.next = current!.next
-			current!.next?.previous = current!.previous
+			let element = current?.element
+			current?.previous?.next = current?.next
+			current?.next?.previous = current?.previous
 			if tail === current {
-				current = tail!.previous
+				current = tail?.previous
 				tail = current
 			} else if head === current {
-				current = head!.next
+				current = head?.next
 				head = current
 			} else {
-				current = current!.next
+				current = current?.next
 			}
 			count -= 1
 			return element
@@ -381,18 +381,18 @@ public class DoublyLinkedList<Element>: CustomStringConvertible, Sequence {
 }
 
 public func +<Element>(lhs: DoublyLinkedList<Element>, rhs: DoublyLinkedList<Element>) -> DoublyLinkedList<Element> {
-	let l: DoublyLinkedList<Element> = DoublyLinkedList<Element>()
+	let l = DoublyLinkedList<Element>()
 	for x in lhs {
-		l.insertAtBack(x!)
+		l.insertAtBack(x)
 	}
 	for x in rhs {
-		l.insertAtBack(x!)
+		l.insertAtBack(x)
 	}
 	return l
 }
 
 public func +=<Element>(lhs: DoublyLinkedList<Element>, rhs: DoublyLinkedList<Element>) {
 	for x in rhs {
-		lhs.insertAtBack(x!)
+		lhs.insertAtBack(x)
 	}
 }

Sources/Queue.swift

@@ -29,7 +29,7 @@
 */
 
 public class Queue<Element>: CustomStringConvertible, Sequence {
-	public typealias Iterator = AnyIterator<Element?>
+	public typealias Iterator = AnyIterator<Element>
 
 	/**
 		:name:	list
@@ -121,18 +121,18 @@ public class Queue<Element>: CustomStringConvertible, Sequence {
 }
 
 public func +<Element>(lhs: Queue<Element>, rhs: Queue<Element>) -> Queue<Element> {
-	let q: Queue<Element> = Queue<Element>()
+	let q = Queue<Element>()
 	for x in lhs {
-		q.enqueue(x!)
+		q.enqueue(x)
 	}
 	for x in rhs {
-		q.enqueue(x!)
+		q.enqueue(x)
 	}
 	return q
 }
 
 public func +=<Element>(lhs: Queue<Element>, rhs: Queue<Element>) {
 	for x in rhs {
-		lhs.enqueue(x!)
+		lhs.enqueue(x)
 	}
 }