Dactyloidae iOS initial commit

mobile/ios/Shared/Functions.swift

@@ -0,0 +1,253 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+import SwiftyJSON
+
+// Pipelining.
+precedencegroup PipelinePrecedence {
+    associativity: left
+}
+infix operator |> : PipelinePrecedence
+
+public func |> <T, U>(x: T, f: (T) -> U) -> U {
+    return f(x)
+}
+
+// Basic currying.
+public func curry<A, B>(_ f: @escaping (A) -> B) -> (A) -> B {
+    return { a in
+        return f(a)
+    }
+}
+
+public func curry<A, B, C>(_ f: @escaping (A, B) -> C) -> (A) -> (B) -> C {
+    return { a in
+        return { b in
+            return f(a, b)
+        }
+    }
+}
+
+public func curry<A, B, C, D>(_ f: @escaping (A, B, C) -> D) -> (A) -> (B) -> (C) -> D {
+    return { a in
+        return { b in
+            return { c in
+                return f(a, b, c)
+            }
+        }
+    }
+}
+
+public func curry<A, B, C, D, E>(_ f: @escaping (A, B, C, D) -> E) -> (A, B, C) -> (D) -> E {
+    return { (a, b, c) in
+        return { d in
+            return f(a, b, c, d)
+        }
+    }
+}
+
+// Function composition.
+infix operator •
+
+public func •<T, U, V>(f: @escaping (T) -> U, g: @escaping (U) -> V) -> (T) -> V {
+    return { t in
+        return g(f(t))
+    }
+}
+public func •<T, V>(f: @escaping (T) -> Void, g: @escaping () -> V) -> (T) -> V {
+    return { t in
+        f(t)
+        return g()
+    }
+}
+public func •<V>(f: @escaping () -> Void, g: @escaping () -> V) -> () -> V {
+    return {
+        f()
+        return g()
+    }
+}
+
+// Why not simply provide an override for ==? Well, that's scary, and can accidentally recurse.
+// This is enough to catch arrays, which Swift will delegate to element-==.
+public func optArrayEqual<T: Equatable>(_ lhs: [T]?, rhs: [T]?) -> Bool {
+    switch (lhs, rhs) {
+    case (.none, .none):
+        return true
+    case (.none, _):
+        return false
+    case (_, .none):
+        return false
+    default:
+        // This delegates to Swift's own array '==', which calls T's == on each element.
+        return lhs! == rhs!
+    }
+}
+
+/**
+ * Given an array, return an array of slices of size `by` (possibly excepting the last slice).
+ *
+ * If `by` is longer than the input, returns a single chunk.
+ * If `by` is less than 1, acts as if `by` is 1.
+ * If the length of the array isn't a multiple of `by`, the final slice will
+ * be smaller than `by`, but never empty.
+ *
+ * If the input array is empty, returns an empty array.
+ */
+
+public func chunk<T>(_ arr: [T], by: Int) -> [ArraySlice<T>] {
+    var result = [ArraySlice<T>]()
+    var chunk = -1
+    let size = max(1, by)
+    for (index, elem) in arr.enumerated() {
+        if index % size == 0 {
+            result.append(ArraySlice<T>())
+            chunk += 1
+        }
+        result[chunk].append(elem)
+    }
+    return result
+}
+
+public func chunkCollection<E, X, T: Collection>(_ items: T, by: Int, f: ([E]) -> [X]) -> [X] where T.Iterator.Element == E {
+    assert(by >= 0)
+    let max = by > 0 ? by : 1
+    var i = 0
+    var acc: [E] = []
+    var results: [X] = []
+    var iter = items.makeIterator()
+
+    while let item = iter.next() {
+        if i >= max {
+            results.append(contentsOf: f(acc))
+            acc = []
+            i = 0
+        }
+        acc.append(item)
+        i += 1
+    }
+
+    if !acc.isEmpty {
+        results.append(contentsOf: f(acc))
+    }
+
+    return results
+}
+
+public extension Sequence {
+    // [T] -> (T -> K) -> [K: [T]]
+    // As opposed to `groupWith` (to follow Haskell's naming), which would be
+    // [T] -> (T -> K) -> [[T]]
+    func groupBy<Key, Value>(_ selector: (Self.Iterator.Element) -> Key, transformer: (Self.Iterator.Element) -> Value) -> [Key: [Value]] {
+        var acc: [Key: [Value]] = [:]
+        for x in self {
+            let k = selector(x)
+            var a = acc[k] ?? []
+            a.append(transformer(x))
+            acc[k] = a
+        }
+        return acc
+    }
+
+    func zip<S: Sequence>(_ elems: S) -> [(Self.Iterator.Element, S.Iterator.Element)] {
+        var rights = elems.makeIterator()
+        return self.flatMap { lhs in
+            guard let rhs = rights.next() else {
+                return nil
+            }
+            return (lhs, rhs)
+        }
+    }
+}
+
+public func optDictionaryEqual<K, V: Equatable>(_ lhs: [K: V]?, rhs: [K: V]?) -> Bool {
+    switch (lhs, rhs) {
+    case (.none, .none):
+        return true
+    case (.none, _):
+        return false
+    case (_, .none):
+        return false
+    default:
+        return lhs! == rhs!
+    }
+}
+
+/**
+ * Return members of `a` that aren't nil, changing the type of the sequence accordingly.
+ */
+public func optFilter<T>(_ a: [T?]) -> [T] {
+    return a.flatMap { $0 }
+}
+
+/**
+ * Return a new map with only key-value pairs that have a non-nil value.
+ */
+public func optFilter<K, V>(_ source: [K: V?]) -> [K: V] {
+    var m = [K: V]()
+    for (k, v) in source {
+        if let v = v {
+            m[k] = v
+        }
+    }
+    return m
+}
+
+/**
+ * Map a function over the values of a map.
+ */
+public func mapValues<K, T, U>(_ source: [K: T], f: ((T) -> U)) -> [K: U] {
+    var m = [K: U]()
+    for (k, v) in source {
+        m[k] = f(v)
+    }
+    return m
+}
+
+public func findOneValue<K, V>(_ map: [K: V], f: (V) -> Bool) -> V? {
+    for v in map.values {
+        if f(v) {
+            return v
+        }
+    }
+    return nil
+}
+
+/**
+ * Take a JSON array, returning the String elements as an array.
+ * It's usually convenient for this to accept an optional.
+ */
+public func jsonsToStrings(_ arr: [JSON]?) -> [String]? {
+    return arr?.flatMap { $0.stringValue }
+}
+
+// Encapsulate a callback in a way that we can use it with NSTimer.
+private class Callback {
+    private let handler:() -> Void
+
+    init(handler:@escaping () -> Void) {
+        self.handler = handler
+    }
+
+    @objc
+    func go() {
+        handler()
+    }
+}
+
+/**
+ * Taken from http://stackoverflow.com/questions/27116684/how-can-i-debounce-a-method-call
+ * Allows creating a block that will fire after a delay. Resets the timer if called again before the delay expires.
+ **/
+public func debounce(_ delay: TimeInterval, action:@escaping () -> Void) -> () -> Void {
+    let callback = Callback(handler: action)
+    var timer: Timer?
+
+    return {
+        // If calling again, invalidate the last timer.
+        if let timer = timer {
+            timer.invalidate()
+        }
+        timer = Timer(timeInterval: delay, target: callback, selector: #selector(Callback.go), userInfo: nil, repeats: false)
+        RunLoop.current.add(timer!, forMode: RunLoopMode.defaultRunLoopMode)
+    }
+}