Use Swift 2-isms where applicable

We should use guard-let wherever we have an early exit and can manage.
Let the compiler enforce our requirements.

Signed-off-by: Stephen Celis <stephen@stephencelis.com>

Author: stephencelis

Source/Extensions/FTS4.swift

@@ -143,13 +143,13 @@ extension Connection {
     public func registerTokenizer(submoduleName: String, next: String -> (String, Range<String.Index>)?) throws {
         try check(_SQLiteRegisterTokenizer(handle, Tokenizer.moduleName, submoduleName) { input, offset, length in
             let string = String.fromCString(input)!
-            if let (token, range) = next(string) {
-                let view = string.utf8
-                offset.memory += string.substringToIndex(range.startIndex).utf8.count
-                length.memory = Int32(range.startIndex.samePositionIn(view).distanceTo(range.endIndex.samePositionIn(view)))
-                return token
-            }
-            return nil
+
+            guard let (token, range) = next(string) else { return nil }
+
+            let view = string.utf8
+            offset.memory += string.substringToIndex(range.startIndex).utf8.count
+            length.memory = Int32(range.startIndex.samePositionIn(view).distanceTo(range.endIndex.samePositionIn(view)))
+            return token
         })
     }
 

Source/Helpers.swift

@@ -101,16 +101,16 @@ extension String {
 }
 
 @warn_unused_result func transcode(literal: Binding?) -> String {
-    if let literal = literal {
-        if let literal = literal as? NSData {
-            let buf = UnsafeBufferPointer(start: UnsafePointer<UInt8>(literal.bytes), count: literal.length)
-            let hex = buf.map { String(format: "%02x", $0) }.joinWithSeparator("")
-            return "x'\(hex)'"
-        }
-        if let literal = literal as? String { return literal.quote("'") }
-        return "\(literal)"
+    guard let literal = literal else { return "NULL" }
+
+    switch literal {
+    case let blob as Blob:
+        return blob.description
+    case let string as String:
+        return string.quote("'")
+    case let binding:
+        return "\(binding)"
     }
-    return "NULL"
 }
 
 @warn_unused_result func value<A: Value>(v: Binding) -> A {

Source/Typed/Query.swift

@@ -989,19 +989,24 @@ public struct Row {
     }
     public func get<V: Value>(column: Expression<V?>) -> V? {
         func valueAtIndex(idx: Int) -> V? {
-            if let value = values[idx] as? V.Datatype { return (V.fromDatatypeValue(value) as! V) }
-            return nil
+            guard let value = values[idx] as? V.Datatype else { return nil }
+            return (V.fromDatatypeValue(value) as? V)!
         }
 
-        if let idx = columnNames[column.template] { return valueAtIndex(idx) }
-
-        let similar = Array(columnNames.keys).filter { $0.hasSuffix(".\(column.template)") }
-        if similar.count == 1 { return valueAtIndex(columnNames[similar[0]]!) }
+        guard let idx = columnNames[column.template] else {
+            let similar = Array(columnNames.keys).filter { $0.hasSuffix(".\(column.template)") }
 
-        if similar.count > 1 {
-            fatalError("ambiguous column '\(column.template)' (please disambiguate: \(similar))")
+            switch similar.count {
+            case 0:
+                fatalError("no such column '\(column.template)' in columns: \(columnNames.keys.sort())")
+            case 1:
+                return valueAtIndex(columnNames[similar[0]]!)
+            default:
+                fatalError("ambiguous column '\(column.template)' (please disambiguate: \(similar))")
+            }
         }
-        fatalError("no such column '\(column.template)' in columns: \(columnNames.keys.sort())")
+
+        return valueAtIndex(idx)
     }
 
     // FIXME: rdar://problem/18673897 // subscript<T>…