Updating to Swift3 (enum lowercase)

Binary Search Tree/Solution 2/BinarySearchTree.playground/Contents.swift

@@ -1,7 +1,7 @@
 //: Playground - noun: a place where people can play
 
 // Each time you insert something, you get back a completely new tree.
-var tree = BinarySearchTree.Leaf(7)
+var tree = BinarySearchTree.leaf(7)
 tree = tree.insert(newValue: 2)
 tree = tree.insert(newValue: 5)
 tree = tree.insert(newValue: 10)

Binary Search Tree/Solution 2/BinarySearchTree.playground/Sources/BinarySearchTree.swift

@@ -4,25 +4,25 @@
   The tree is immutable. Any insertions or deletions will create a new tree.
 */
 public enum BinarySearchTree<T: Comparable> {
-  case Empty
-  case Leaf(T)
-  indirect case Node(BinarySearchTree, T, BinarySearchTree)
+  case empty
+  case leaf(T)
+  indirect case node(BinarySearchTree, T, BinarySearchTree)
 
   /* How many nodes are in this subtree. Performance: O(n). */
   public var count: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return left.count + 1 + right.count
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return left.count + 1 + right.count
     }
   }
 
   /* Distance of this node to its lowest leaf. Performance: O(n). */
   public var height: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return 1 + max(left.height, right.height)
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return 1 + max(left.height, right.height)
     }
   }
 
@@ -32,21 +32,21 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func insert(newValue: T) -> BinarySearchTree {
     switch self {
-    case .Empty:
-      return .Leaf(newValue)
+    case .empty:
+      return .leaf(newValue)
 
-    case .Leaf(let value):
+    case .leaf(let value):
       if newValue < value {
-        return .Node(.Leaf(newValue), value, .Empty)
+        return .node(.leaf(newValue), value, .empty)
       } else {
-        return .Node(.Empty, value, .Leaf(newValue))
+        return .node(.empty, value, .leaf(newValue))
       }
 
-    case .Node(let left, let value, let right):
+    case .node(let left, let value, let right):
       if newValue < value {
-        return .Node(left.insert(newValue: newValue), value, right)
+        return .node(left.insert(newValue: newValue), value, right)
       } else {
-        return .Node(left, value, right.insert(newValue: newValue))
+        return .node(left, value, right.insert(newValue: newValue))
       }
     }
   }
@@ -57,11 +57,11 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func search(x: T) -> BinarySearchTree? {
     switch self {
-    case .Empty:
+    case .empty:
       return nil
-    case .Leaf(let y):
+    case .leaf(let y):
       return (x == y) ? self : nil
-    case let .Node(left, y, right):
+    case let .node(left, y, right):
       if x < y {
         return left.search(x: x)
       } else if y < x {
@@ -82,11 +82,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func minimum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(next, _, _) = node {
+    while case let .node(next, _, _) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -98,11 +98,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func maximum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(_, _, next) = node {
+    while case let .node(_, _, next) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -112,9 +112,9 @@ public enum BinarySearchTree<T: Comparable> {
 extension BinarySearchTree: CustomDebugStringConvertible {
   public var debugDescription: String {
     switch self {
-    case .Empty: return "."
-    case .Leaf(let value): return "\(value)"
-    case .Node(let left, let value, let right):
+    case .empty: return "."
+    case .leaf(let value): return "\(value)"
+    case .node(let left, let value, let right):
       return "(\(left.debugDescription) <- \(value) -> \(right.debugDescription))"
     }
   }

Binary Search Tree/Solution 2/BinarySearchTree.swift

@@ -4,25 +4,25 @@
   The tree is immutable. Any insertions or deletions will create a new tree.
 */
 public enum BinarySearchTree<T: Comparable> {
-  case Empty
-  case Leaf(T)
-  indirect case Node(BinarySearchTree, T, BinarySearchTree)
+  case empty
+  case leaf(T)
+  indirect case node(BinarySearchTree, T, BinarySearchTree)
 
   /* How many nodes are in this subtree. Performance: O(n). */
   public var count: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return left.count + 1 + right.count
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return left.count + 1 + right.count
     }
   }
 
   /* Distance of this node to its lowest leaf. Performance: O(n). */
   public var height: Int {
     switch self {
-    case .Empty: return 0
-    case .Leaf: return 1
-    case let .Node(left, _, right): return 1 + max(left.height, right.height)
+    case .empty: return 0
+    case .leaf: return 1
+    case let .node(left, _, right): return 1 + max(left.height, right.height)
     }
   }
 
@@ -32,21 +32,21 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func insert(newValue: T) -> BinarySearchTree {
     switch self {
-    case .Empty:
-      return .Leaf(newValue)
+    case .empty:
+      return .leaf(newValue)
 
-    case .Leaf(let value):
+    case .leaf(let value):
       if newValue < value {
-        return .Node(.Leaf(newValue), value, .Empty)
+        return .node(.leaf(newValue), value, .empty)
       } else {
-        return .Node(.Empty, value, .Leaf(newValue))
+        return .node(.empty, value, .leaf(newValue))
       }
 
-    case .Node(let left, let value, let right):
+    case .node(let left, let value, let right):
       if newValue < value {
-        return .Node(left.insert(newValue), value, right)
+        return .node(left.insert(newValue), value, right)
       } else {
-        return .Node(left, value, right.insert(newValue))
+        return .node(left, value, right.insert(newValue))
       }
     }
   }
@@ -57,11 +57,11 @@ public enum BinarySearchTree<T: Comparable> {
   */
   public func search(x: T) -> BinarySearchTree? {
     switch self {
-    case .Empty:
+    case .empty:
       return nil
-    case .Leaf(let y):
+    case .leaf(let y):
       return (x == y) ? self : nil
-    case let .Node(left, y, right):
+    case let .node(left, y, right):
       if x < y {
         return left.search(x)
       } else if y < x {
@@ -82,11 +82,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func minimum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(next, _, _) = node {
+    while case let .node(next, _, _) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -98,11 +98,11 @@ public enum BinarySearchTree<T: Comparable> {
   public func maximum() -> BinarySearchTree {
     var node = self
     var prev = node
-    while case let .Node(_, _, next) = node {
+    while case let .node(_, _, next) = node {
       prev = node
       node = next
     }
-    if case .Leaf = node {
+    if case .leaf = node {
       return node
     }
     return prev
@@ -112,9 +112,9 @@ public enum BinarySearchTree<T: Comparable> {
 extension BinarySearchTree: CustomDebugStringConvertible {
   public var debugDescription: String {
     switch self {
-    case .Empty: return "."
-    case .Leaf(let value): return "\(value)"
-    case .Node(let left, let value, let right):
+    case .empty: return "."
+    case .leaf(let value): return "\(value)"
+    case .node(let left, let value, let right):
       return "(\(left.debugDescription) <- \(value) -> \(right.debugDescription))"
     }
   }

Counting Sort/CountingSort.playground/Contents.swift

@@ -1,12 +1,12 @@
 //: Playground - noun: a place where people can play
 
 enum CountingSortError: Error {
-  case ArrayEmpty
+  case arrayEmpty
 }
 
 func countingSort(array: [Int]) throws -> [Int] {
   guard array.count > 0 else {
-    throw CountingSortError.ArrayEmpty
+    throw CountingSortError.arrayEmpty
   }
 
   // Step 1
@@ -38,4 +38,4 @@ func countingSort(array: [Int]) throws -> [Int] {
 }
 
 
-try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])
+try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])

Counting Sort/CountingSort.swift

@@ -7,12 +7,12 @@
 //
 
 enum CountingSortError: ErrorType {
-  case ArrayEmpty
+  case arrayEmpty
 }
 
 func countingSort(array: [Int]) throws -> [Int] {
   guard array.count > 0 else {
-    throw CountingSortError.ArrayEmpty
+    throw CountingSortError.arrayEmpty
   }
 
   // Step 1

Linked List/README.markdown

@@ -526,8 +526,8 @@ It is possible to implement a linked list with value semantics using an enum. Th
 
 ```swift
 enum ListNode<T> {
-  indirect case Node(T, next: ListNode<T>)
-  case End
+  indirect case node(T, next: ListNode<T>)
+  case end
 }
 ```