Reorganize Prelude (#2)

* Reorganize Prelude

* Feedback + tests

Author: stephencelis

Prelude.xcodeproj/project.pbxproj

@@ -0,0 +1,68 @@
+public func uncons<A>(_ xs: [A]) -> (A, [A])? {
+  guard let x = xs.first else { return nil }
+  return (x, Array(xs.dropFirst()))
+}
+
+public func <¢> <A, B> (f: (A) -> B, xs: [A]) -> [B] {
+  return xs.map(f)
+}
+
+public func <*> <A, B> (fs: [(A) -> B], xs: [A]) -> [B] {
+  return fs.flatMap { f in xs.map(f) }
+}
+
+public func foldMap<A, M: Monoid>(_ f: @escaping (A) -> M) -> ([A]) -> M {
+  return { xs in
+    xs.reduce(M.e) { accum, x in accum <> f(x) }
+  }
+}
+
+public func partition<A>(_ p: @escaping (A) -> Bool) -> ([A]) -> ([A], [A]) {
+  return { xs in
+    xs.reduce(([], [])) { accum, x in
+      p(x) ? (accum.0 + [x], accum.1) : (accum.0, accum.1 + [x])
+    }
+  }
+}
+
+public func elem<A: Equatable>(_ x: A) -> ([A]) -> Bool {
+  return { xs in xs.contains(x) }
+}
+
+public func elem<A: Equatable>(of xs: [A]) -> (A) -> Bool {
+  return { x in xs.contains(x) }
+}
+
+public func zipWith<A, B, C>(_ f: @escaping (A, B) -> C) -> ([A]) -> ([B]) -> [C] {
+  return { xs in
+    return { ys in
+      return zip(xs, ys).map { f($0.0, $0.1) }
+    }
+  }
+}
+
+public func sorted<A>(by f: @escaping (A, A) -> Bool) -> ([A]) -> [A] {
+  return { xs in
+    xs.sorted(by: f)
+  }
+}
+
+public func lookup<A: Equatable, B>(_ x: A) -> ([(A, B)]) -> B? {
+  return { pairs in
+    pairs.first { pair in pair.0 == x }.map(second)
+  }
+}
+
+public func catOptionals<A>(_ xs: [A?]) -> [A] {
+  return xs |> mapOptional(id)
+}
+
+public func mapOptional<A, B>(_ f: @escaping (A) -> B?) -> ([A]) -> [B] {
+  return { xs in
+    xs.flatMap(f)
+  }
+}
+
+public func replicate<A>(_ n: Int) -> (A) -> [A] {
+  return { a in (1...n).map(const(a)) }
+}

Sources/Prelude/Array.swift

@@ -0,0 +1,21 @@
+func left<A, B, C>(_ a2b: @escaping (A) -> B) -> (Either<A, C>) -> Either<B, C> {
+  return { either in
+    switch either {
+    case let .left(a):
+      return .left(a2b(a))
+    case let .right(c):
+      return .right(c)
+    }
+  }
+}
+
+func right<A, B, C>(_ b2c: @escaping (B) -> C) -> (Either<A, B>) -> Either<A, C> {
+  return { either in
+    switch either {
+    case let .left(a):
+      return .left(a)
+    case let .right(c):
+      return .right(b2c(c))
+    }
+  }
+}

Sources/Prelude/Choice.swift

@@ -0,0 +1,28 @@
+public enum Either<L, R> {
+  case left(L)
+  case right(R)
+}
+
+extension Either {
+  public var left: L? {
+    switch self {
+    case let .left(x):
+      return x
+    case .right:
+      return nil
+    }
+  }
+
+  public var right: R? {
+    switch self {
+    case .left:
+      return nil
+    case let .right(x):
+      return x
+    }
+  }
+}
+
+public func rights<L, R>(_ xs: [Either<L, R>]) -> [R] {
+  return xs |> mapOptional { $0.right }
+}

Sources/Prelude/Either.swift

@@ -0,0 +1,23 @@
+public func id<A>(_ a: A) -> A {
+  return a
+}
+
+public func <<< <A, B, C>(_ b2c: @escaping (B) -> C, _ a2b: @escaping (A) -> B) -> (A) -> C {
+  return { a in b2c(a2b(a)) }
+}
+
+public func >>> <A, B, C>(_ a2b: @escaping (A) -> B, _ b2c: @escaping (B) -> C) -> (A) -> C {
+  return { a in b2c(a2b(a)) }
+}
+
+public func const<A, B>(_ a: A) -> (B) -> A {
+  return { _ in a }
+}
+
+public func <| <A, B> (f: (A) -> B, a: A) -> B {
+  return f(a)
+}
+
+public func |> <A, B> (a: A, f: (A) -> B) -> B {
+  return f(a)
+}

Sources/Prelude/Function.swift

@@ -0,0 +1,32 @@
+public protocol Monoid: Semigroup {
+  static var e: Self { get }
+}
+
+public func concat<M: Monoid>(_ xs: [M]) -> M {
+  return xs.reduce(M.e, <>)
+}
+
+extension String: Monoid {
+  public static let e = ""
+
+  public static func <>(lhs: String, rhs: String) -> String {
+    return lhs + rhs
+  }
+}
+
+extension Array: Monoid {
+  public static var e: Array { return [] }
+
+  public static func <>(lhs: Array, rhs: Array) -> Array {
+    return lhs + rhs
+  }
+}
+
+public func joined<M: Monoid>(_ s: M) -> ([M]) -> M {
+  return { xs in
+    if let head = xs.first {
+      return xs.dropFirst().reduce(head) { accum, x in accum <> s <> x }
+    }
+    return .e
+  }
+}

Sources/Prelude/Monoid.swift

@@ -0,0 +1,61 @@
+precedencegroup HashRocket {
+  associativity: left
+  higherThan: Semigroup
+}
+infix operator =>: HashRocket
+
+precedencegroup Alt {
+  associativity: left
+}
+
+precedencegroup Apply {
+  higherThan: Alt
+  associativity: left
+}
+
+precedencegroup Functor {
+  higherThan: Apply
+  associativity: left
+}
+
+precedencegroup FunctionApplication {
+  associativity: left
+  higherThan: Semigroup
+}
+
+precedencegroup FunctionApplicationFlipped {
+  associativity: left
+  higherThan: FunctionApplication
+}
+
+precedencegroup Semigroup {
+  associativity: right
+  higherThan: AdditionPrecedence
+}
+
+precedencegroup FunctionComposition {
+  associativity: right
+}
+
+precedencegroup MonadicBind {
+  associativity: right
+}
+
+
+infix operator <<<: FunctionComposition
+infix operator >>>: FunctionComposition
+infix operator <|: FunctionApplication
+infix operator |>: FunctionApplicationFlipped
+infix operator <|>: Alt
+infix operator <*>: Apply
+infix operator <*: Apply
+infix operator *>: Apply
+
+infix operator <¢>: Functor
+infix operator <¢: Functor
+
+infix operator <>: Semigroup
+prefix operator <>
+postfix operator <>
+
+infix operator >>-: MonadicBind

Sources/Prelude/Operators.swift

@@ -0,0 +1,3 @@
+public func coalesce<A>(with `default`: A) -> (A?) -> A {
+  return { x in x ?? `default` }
+}