Merge pull request kodecocodes#397 from dsantosp12/master

Added ExpressibleByArrayLiteral to the Linked List and Tests

Author: kelvinlauKL

Linked List/LinkedList.playground/Contents.swift

@@ -4,25 +4,27 @@ public class LinkedListNode<T> {
   var value: T
   var next: LinkedListNode?
   weak var previous: LinkedListNode?
-
+  
   public init(value: T) {
     self.value = value
   }
 }
 
-public class LinkedList<T> {
+public final class LinkedList<T> {
   public typealias Node = LinkedListNode<T>
-
+  
   fileprivate var head: Node?
-
+  
+  public init() {}
+  
   public var isEmpty: Bool {
     return head == nil
   }
-
+  
   public var first: Node? {
     return head
   }
-
+  
   public var last: Node? {
     if var node = head {
       while case let next? = node.next {
@@ -33,7 +35,7 @@ public class LinkedList<T> {
       return nil
     }
   }
-
+  
   public var count: Int {
     if var node = head {
       var c = 1
@@ -46,7 +48,7 @@ public class LinkedList<T> {
       return 0
     }
   }
-
+  
   public func node(atIndex index: Int) -> Node? {
     if index >= 0 {
       var node = head
@@ -59,80 +61,88 @@ public class LinkedList<T> {
     }
     return nil
   }
-
+  
   public subscript(index: Int) -> T {
     let node = self.node(atIndex: index)
     assert(node != nil)
     return node!.value
   }
-
+  
   public func append(_ value: T) {
     let newNode = Node(value: value)
+    self.append(newNode)
+  }
+  
+  public func append(_ newNode: Node) {
     if let lastNode = last {
       newNode.previous = lastNode
       lastNode.next = newNode
     } else {
       head = newNode
     }
   }
-
+  
   private func nodesBeforeAndAfter(index: Int) -> (Node?, Node?) {
     assert(index >= 0)
-
+    
     var i = index
     var next = head
     var prev: Node?
-
+    
     while next != nil && i > 0 {
       i -= 1
       prev = next
       next = next!.next
     }
     assert(i == 0)  // if > 0, then specified index was too large
-
+    
     return (prev, next)
   }
-
+  
   public func insert(_ value: T, atIndex index: Int) {
-    let (prev, next) = nodesBeforeAndAfter(index: index)
-
     let newNode = Node(value: value)
+    self.insert(newNode, atIndex: index)
+  }
+  
+  public func insert(_ newNode: Node, atIndex index: Int) {
+    let (prev, next) = nodesBeforeAndAfter(index: index)
+    
     newNode.previous = prev
     newNode.next = next
     prev?.next = newNode
     next?.previous = newNode
-
+    
     if prev == nil {
       head = newNode
     }
   }
-
+  
   public func removeAll() {
     head = nil
   }
-
-  public func remove(node: Node) -> T {
+  
+  @discardableResult public func remove(node: Node) -> T {
     let prev = node.previous
     let next = node.next
-
+    
     if let prev = prev {
       prev.next = next
     } else {
       head = next
     }
     next?.previous = prev
-
+    
     node.previous = nil
     node.next = nil
     return node.value
   }
-
-  public func removeLast() -> T {
+  
+  @discardableResult public func removeLast() -> T {
     assert(!isEmpty)
     return remove(node: last!)
   }
-
-  public func remove(atIndex index: Int) -> T {
+  
+  @discardableResult public func remove(atIndex index: Int) -> T {
     let node = self.node(atIndex: index)
     assert(node != nil)
     return remove(node: node!)
@@ -173,7 +183,7 @@ extension LinkedList {
     }
     return result
   }
-
+  
   public func filter(predicate: (T) -> Bool) -> LinkedList<T> {
     let result = LinkedList<T>()
     var node = head
@@ -190,13 +200,23 @@ extension LinkedList {
 extension LinkedList {
   convenience init(array: Array<T>) {
     self.init()
-        
+    
     for element in array {
       self.append(element)
     }
   }
 }
 
+extension LinkedList: ExpressibleByArrayLiteral {
+  public convenience init(arrayLiteral elements: T...) {
+    self.init()
+    
+    for element in elements {
+      self.append(element)
+    }
+  }
+}
+
 let list = LinkedList<String>()
 list.isEmpty                  // true
 list.first                    // nil
@@ -255,3 +275,13 @@ list[0]                        // "Swift"
 
 list.remove(atIndex: 0)        // "Swift"
 list.count                     // 0
+
+let linkedList: LinkedList<Int> = [1, 2, 3, 4] // [1, 2, 3, 4]
+linkedList.count               // 4
+linkedList[0]                  // 1
+
+// Infer the type from the array
+let listArrayLiteral2: LinkedList = ["Swift", "Algorithm", "Club"]
+listArrayLiteral2.count        // 3
+listArrayLiteral2[0]           // "Swift"
+listArrayLiteral2.removeLast() // "Club"

Linked List/LinkedList.swift

@@ -8,7 +8,7 @@ public class LinkedListNode<T> {
     }
 }
 
-public class LinkedList<T> {
+public final class LinkedList<T> {
     public typealias Node = LinkedListNode<T>
 
     fileprivate var head: Node?
@@ -204,3 +204,13 @@ extension LinkedList {
         }
     }
 }
+
+extension LinkedList: ExpressibleByArrayLiteral {
+  public convenience init(arrayLiteral elements: T...) {
+    self.init()
+    
+    for element in elements {
+      self.append(element)
+    }
+  }
+}

Linked List/Tests/LinkedListTests.swift

@@ -248,4 +248,26 @@ class LinkedListTest: XCTestCase {
     XCTAssertTrue(last === list.first)
     XCTAssertEqual(nodeCount, list.count)
   }
+  
+  func testArrayLiteralInitTypeInfer() {
+    let arrayLiteralInitInfer: LinkedList = [1.0, 2.0, 3.0]
+    
+    XCTAssertEqual(arrayLiteralInitInfer.count, 3)
+    XCTAssertEqual(arrayLiteralInitInfer.first?.value, 1.0)
+    XCTAssertEqual(arrayLiteralInitInfer.last?.value, 3.0)
+    XCTAssertEqual(arrayLiteralInitInfer[1], 2.0)
+    XCTAssertEqual(arrayLiteralInitInfer.removeLast(), 3.0)
+    XCTAssertEqual(arrayLiteralInitInfer.count, 2)
+  }
+  
+  func testArrayLiteralInitExplicit() {
+    let arrayLiteralInitExplicit: LinkedList<Int> = [1, 2, 3]
+    
+    XCTAssertEqual(arrayLiteralInitExplicit.count, 3)
+    XCTAssertEqual(arrayLiteralInitExplicit.first?.value, 1)
+    XCTAssertEqual(arrayLiteralInitExplicit.last?.value, 3)
+    XCTAssertEqual(arrayLiteralInitExplicit[1], 2)
+    XCTAssertEqual(arrayLiteralInitExplicit.removeLast(), 3)
+    XCTAssertEqual(arrayLiteralInitExplicit.count, 2)
+  }
 }