Skip to content

Commit b734b6e

Browse files
CodaFiCodaFi
committed
Formatting
1 parent 192d7f2 commit b734b6e

File tree

7 files changed

+141
-133
lines changed

7 files changed

+141
-133
lines changed

‎Swiftz/Curry.swift‎

Lines changed: 52 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -14,56 +14,56 @@ public func curry<A, B, C>(f : (A, B) -> C) -> A -> B -> C {
1414
return { a in { b in f(a, b) } }
1515
}
1616

17-
public func curry<A,B,C,D>(f: (A,B,C) -> D) -> A -> B -> C -> D {
18-
return { a in { b in { c in f(a,b,c) } } }
17+
public func curry<A, B, C, D>(f : (A, B, C) -> D) -> A -> B -> C -> D {
18+
return { a in { b in { c in f(a, b, c) } } }
1919
}
2020

21-
public func curry<A,B,C,D,E>(f: (A,B,C,D) -> E) -> A -> B -> C -> D -> E {
22-
return { a in { b in { c in { d in f(a,b,c,d) } } } }
21+
public func curry<A, B, C, D, E>(f : (A, B, C, D) -> E) -> A -> B -> C -> D -> E {
22+
return { a in { b in { c in { d in f(a, b, c, d) } } } }
2323
}
2424

25-
public func curry<A,B,C,D,E,F>(f: (A,B,C,D,E) -> F) -> A -> B -> C -> D -> E -> F {
26-
return { a in { b in { c in { d in { e in f(a,b,c,d,e) } } } } }
25+
public func curry<A, B, C, D, E, F>(f : (A, B, C, D, E) -> F) -> A -> B -> C -> D -> E -> F {
26+
return { a in { b in { c in { d in { e in f(a, b, c, d, e) } } } } }
2727
}
2828

29-
public func curry<A,B,C,D,E,F,G>(f: (A,B,C,D,E,F) -> G) -> A -> B -> C -> D -> E -> F -> G {
30-
return { a in { b in { c in { d in { e in { ff in f(a,b,c,d,e,ff) } } } } } }
29+
public func curry<A, B, C, D, E, F, G>(f : (A, B, C, D, E, F) -> G) -> A -> B -> C -> D -> E -> F -> G {
30+
return { a in { b in { c in { d in { e in { ff in f(a, b, c, d, e, ff) } } } } } }
3131
}
3232

33-
public func curry<A,B,C,D,E,F,G,H>(f: (A,B,C,D,E,F,G) -> H) -> A -> B -> C -> D -> E -> F -> G -> H {
34-
return { a in { b in { c in { d in { e in { ff in { g in f(a,b,c,d,e,ff,g) } } } } } } }
33+
public func curry<A, B, C, D, E, F, G, H>(f : (A, B, C, D, E, F, G) -> H) -> A -> B -> C -> D -> E -> F -> G -> H {
34+
return { a in { b in { c in { d in { e in { ff in { g in f(a, b, c, d, e, ff, g) } } } } } } }
3535
}
3636

37-
public func curry<A,B,C,D,E,F,G,H,I>(f: (A,B,C,D,E,F,G,H) -> I) -> A -> B -> C -> D -> E -> F -> G -> H -> I {
38-
return { a in { b in { c in { d in { e in { ff in { g in { h in f(a,b,c,d,e,ff,g,h) } } } } } } } }
37+
public func curry<A, B, C, D, E, F, G, H, I>(f : (A, B, C, D, E, F, G, H) -> I) -> A -> B -> C -> D -> E -> F -> G -> H -> I {
38+
return { a in { b in { c in { d in { e in { ff in { g in { h in f(a, b, c, d, e, ff, g, h) } } } } } } } }
3939
}
4040

41-
public func curry<A,B,C,D,E,F,G,H,I,J>(f: (A,B,C,D,E,F,G,H,I) -> J) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J {
42-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in f(a,b,c,d,e,ff,g,h,i) } } } } } } } } }
41+
public func curry<A, B, C, D, E, F, G, H, I, J>(f : (A, B, C, D, E, F, G, H, I) -> J) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J {
42+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in f(a, b, c, d, e, ff, g, h, i) } } } } } } } } }
4343
}
4444

45-
public func curry<A,B,C,D,E,F,G,H,I,J,K>(f: (A,B,C,D,E,F,G,H,I,J) -> K) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K {
46-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in f(a,b,c,d,e,ff,g,h,i,j) } } } } } } } } } }
45+
public func curry<A, B, C, D, E, F, G, H, I, J, K>(f : (A, B, C, D, E, F, G, H, I, J) -> K) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K {
46+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in f(a, b, c, d, e, ff, g, h, i, j) } } } } } } } } } }
4747
}
4848

49-
public func curry<A,B,C,D,E,F,G,H,I,J,K,L>(f: (A,B,C,D,E,F,G,H,I,J,K) -> L) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L {
50-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in f(a,b,c,d,e,ff,g,h,i,j,k) } } } } } } } } } } }
49+
public func curry<A, B, C, D, E, F, G, H, I, J, K, L>(f : (A, B, C, D, E, F, G, H, I, J, K) -> L) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L {
50+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in f(a, b, c, d, e, ff, g, h, i, j, k) } } } } } } } } } } }
5151
}
5252

53-
public func curry<A,B,C,D,E,F,G,H,I,J,K,L,M>(f: (A,B,C,D,E,F,G,H,I,J,K,L) -> M) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M {
54-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in f(a,b,c,d,e,ff,g,h,i,j,k,l) } } } } } } } } } } } }
53+
public func curry<A, B, C, D, E, F, G, H, I, J, K, L, M>(f : (A, B, C, D, E, F, G, H, I, J, K, L) -> M) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M {
54+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in f(a, b, c, d, e, ff, g, h, i, j, k, l) } } } } } } } } } } } }
5555
}
5656

57-
public func curry<A,B,C,D,E,F,G,H,I,J,K,L,M,N>(f: (A,B,C,D,E,F,G,H,I,J,K,L,M) -> N) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N {
58-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in { m in f(a,b,c,d,e,ff,g,h,i,j,k,l,m) } } } } } } } } } } } } }
57+
public func curry<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(f : (A, B, C, D, E, F, G, H, I, J, K, L, M) -> N) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N {
58+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in { m in f(a, b, c, d, e, ff, g, h, i, j, k, l, m) } } } } } } } } } } } } }
5959
}
6060

61-
public func curry<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(f: (A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> O) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O {
62-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in { m in { n in f(a,b,c,d,e,ff,g,h,i,j,k,l,m,n) } } } } } } } } } } } } } }
61+
public func curry<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(f : (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> O) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O {
62+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in { m in { n in f(a, b, c, d, e, ff, g, h, i, j, k, l, m, n) } } } } } } } } } } } } } }
6363
}
6464

65-
public func curry<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(f: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) -> P) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O -> P {
66-
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in { m in { n in { o in f(a,b,c,d,e,ff,g,h,i,j,k,l,m,n,o) } } } } } } } } } } } } } } }
65+
public func curry<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(f : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> P) -> A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O -> P {
66+
return { a in { b in { c in { d in { e in { ff in { g in { h in { i in { j in { k in { l in { m in { n in { o in f(a, b, c, d, e, ff, g, h, i, j, k, l, m, n, o) } } } } } } } } } } } } } } }
6767
}
6868

6969
/// Converts a curried function to an uncurried function.
@@ -74,54 +74,54 @@ public func uncurry<A, B, C>(f : A -> B -> C) -> (A, B) -> C {
7474
return { t in f(t.0)(t.1) }
7575
}
7676

77-
public func uncurry<A,B,C,D>(f: A -> B -> C -> D) -> (A,B,C) -> D {
78-
return { a,b,c in f(a)(b)(c) }
77+
public func uncurry<A, B, C, D>(f : A -> B -> C -> D) -> (A, B, C) -> D {
78+
return { a, b, c in f(a)(b)(c) }
7979
}
8080

81-
public func uncurry<A,B,C,D,E>(f: A -> B -> C -> D -> E) -> (A,B,C,D) -> E {
82-
return { a,b,c,d in f(a)(b)(c)(d) }
81+
public func uncurry<A, B, C, D, E>(f : A -> B -> C -> D -> E) -> (A, B, C, D) -> E {
82+
return { a, b, c, d in f(a)(b)(c)(d) }
8383
}
8484

85-
public func uncurry<A,B,C,D,E,F>(f: A -> B -> C -> D -> E -> F) -> (A,B,C,D,E) -> F {
86-
return { a,b,c,d,e in f(a)(b)(c)(d)(e) }
85+
public func uncurry<A, B, C, D, E, F>(f : A -> B -> C -> D -> E -> F) -> (A, B, C, D, E) -> F {
86+
return { a, b, c, d, e in f(a)(b)(c)(d)(e) }
8787
}
8888

89-
public func uncurry<A,B,C,D,E,F,G>(f: A -> B -> C -> D -> E -> F -> G) -> (A,B,C,D,E,F) -> G {
90-
return { a,b,c,d,e,ff in f(a)(b)(c)(d)(e)(ff) }
89+
public func uncurry<A, B, C, D, E, F, G>(f : A -> B -> C -> D -> E -> F -> G) -> (A, B, C, D, E, F) -> G {
90+
return { a, b, c, d, e, ff in f(a)(b)(c)(d)(e)(ff) }
9191
}
9292

93-
public func uncurry<A,B,C,D,E,F,G,H>(f: A -> B -> C -> D -> E -> F -> G -> H) -> (A,B,C,D,E,F,G) -> H {
94-
return { a,b,c,d,e,ff,g in f(a)(b)(c)(d)(e)(ff)(g) }
93+
public func uncurry<A, B, C, D, E, F, G, H>(f : A -> B -> C -> D -> E -> F -> G -> H) -> (A, B, C, D, E, F, G) -> H {
94+
return { a, b, c, d, e, ff, g in f(a)(b)(c)(d)(e)(ff)(g) }
9595
}
9696

97-
public func uncurry<A,B,C,D,E,F,G,H,I>(f: A -> B -> C -> D -> E -> F -> G -> H -> I) -> (A,B,C,D,E,F,G,H) -> I {
98-
return { a,b,c,d,e,ff,g,h in f(a)(b)(c)(d)(e)(ff)(g)(h) }
97+
public func uncurry<A, B, C, D, E, F, G, H, I>(f : A -> B -> C -> D -> E -> F -> G -> H -> I) -> (A, B, C, D, E, F, G, H) -> I {
98+
return { a, b, c, d, e, ff, g, h in f(a)(b)(c)(d)(e)(ff)(g)(h) }
9999
}
100100

101-
public func uncurry<A,B,C,D,E,F,G,H,I,J>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J) -> (A,B,C,D,E,F,G,H,I) -> J {
102-
return { a,b,c,d,e,ff,g,h,i in f(a)(b)(c)(d)(e)(ff)(g)(h)(i) }
101+
public func uncurry<A, B, C, D, E, F, G, H, I, J>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J) -> (A, B, C, D, E, F, G, H, I) -> J {
102+
return { a, b, c, d, e, ff, g, h, i in f(a)(b)(c)(d)(e)(ff)(g)(h)(i) }
103103
}
104104

105-
public func uncurry<A,B,C,D,E,F,G,H,I,J,K>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K) -> (A,B,C,D,E,F,G,H,I,J) -> K {
106-
return { a,b,c,d,e,ff,g,h,i,j in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j) }
105+
public func uncurry<A, B, C, D, E, F, G, H, I, J, K>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K) -> (A, B, C, D, E, F, G, H, I, J) -> K {
106+
return { a, b, c, d, e, ff, g, h, i, j in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j) }
107107
}
108108

109-
public func uncurry<A,B,C,D,E,F,G,H,I,J,K,L>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L) -> (A,B,C,D,E,F,G,H,I,J,K) -> L {
110-
return { a,b,c,d,e,ff,g,h,i,j,k in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k) }
109+
public func uncurry<A, B, C, D, E, F, G, H, I, J, K, L>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L) -> (A, B, C, D, E, F, G, H, I, J, K) -> L {
110+
return { a, b, c, d, e, ff, g, h, i, j, k in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k) }
111111
}
112112

113-
public func uncurry<A,B,C,D,E,F,G,H,I,J,K,L,M>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M) -> (A,B,C,D,E,F,G,H,I,J,K,L) -> M {
114-
return { a,b,c,d,e,ff,g,h,i,j,k,l in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l) }
113+
public func uncurry<A, B, C, D, E, F, G, H, I, J, K, L, M>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M) -> (A, B, C, D, E, F, G, H, I, J, K, L) -> M {
114+
return { a, b, c, d, e, ff, g, h, i, j, k, l in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l) }
115115
}
116116

117-
public func uncurry<A,B,C,D,E,F,G,H,I,J,K,L,M,N>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N) -> (A,B,C,D,E,F,G,H,I,J,K,L,M) -> N {
118-
return { a,b,c,d,e,ff,g,h,i,j,k,l,m in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l)(m) }
117+
public func uncurry<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N) -> (A, B, C, D, E, F, G, H, I, J, K, L, M) -> N {
118+
return { a, b, c, d, e, ff, g, h, i, j, k, l, m in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l)(m) }
119119
}
120120

121-
public func uncurry<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O) -> (A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> O {
122-
return { a,b,c,d,e,ff,g,h,i,j,k,l,m,n in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l)(m)(n) }
121+
public func uncurry<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> O {
122+
return { a, b, c, d, e, ff, g, h, i, j, k, l, m, n in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l)(m)(n) }
123123
}
124124

125-
public func uncurry<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(f: A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O -> P) -> (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) -> P {
126-
return { a,b,c,d,e,ff,g,h,i,j,k,l,m,n,o in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l)(m)(n)(o) }
125+
public func uncurry<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(f : A -> B -> C -> D -> E -> F -> G -> H -> I -> J -> K -> L -> M -> N -> O -> P) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> P {
126+
return { a, b, c, d, e, ff, g, h, i, j, k, l, m, n, o in f(a)(b)(c)(d)(e)(ff)(g)(h)(i)(j)(k)(l)(m)(n)(o) }
127127
}

‎Swiftz/Iso.swift‎

Lines changed: 19 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -6,53 +6,61 @@
66
// Copyright (c) 2014 Maxwell Swadling. All rights reserved.
77
//
88

9-
9+
/// Captures an isomorphism between S and A and
1010
public struct Iso<S, T, A, B> {
11-
public let get: S -> A
12-
public let inject: B -> T
11+
public let get : S -> A
12+
public let inject : B -> T
1313

14-
public init(get: S -> A, inject: B -> T) {
14+
/// Builds an Iso from a pair of inverse functions.
15+
public init(get : S -> A, inject : B -> T) {
1516
self.get = get
1617
self.inject = inject
1718
}
1819

19-
public func modify(v: S, _ f: A -> B) -> T {
20+
21+
public func modify(v : S, _ f : A -> B) -> T {
2022
return inject(f(get(v)))
2123
}
2224

23-
public var asLens: Lens<S, T, A, B> {
25+
public var asLens : Lens<S, T, A, B> {
2426
return Lens { s in IxStore(self.get(s)) { self.inject($0) } }
2527
}
2628

27-
public var asPrism: Prism<S, T, A, B> {
29+
public var asPrism : Prism<S, T, A, B> {
2830
return Prism(tryGet: { .Some(self.get($0)) }, inject: inject)
2931
}
3032
}
3133

34+
/// The identity isomorphism.
3235
public func identity<S, T>() -> Iso<S, T, S, T> {
3336
return Iso(get: identity, inject: identity)
3437
}
3538

36-
public func • <S, T, I, J, A, B>(i1: Iso<S, T, I, J>, i2: Iso<I, J, A, B>) -> Iso<S, T, A, B> {
39+
/// Compose isomorphisms.
40+
public func • <S, T, I, J, A, B>(i1 : Iso<S, T, I, J>, i2 : Iso<I, J, A, B>) -> Iso<S, T, A, B> {
3741
return Iso(get: i2.get • i1.get, inject: i1.inject • i2.inject)
3842
}
3943

40-
public func comp<S, T, I, J, A, B>(i1: Iso<S, T, I, J>)(i2: Iso<I, J, A, B>) -> Iso<S, T, A, B> {
44+
/// Compose isomorphisms.
45+
public func comp<S, T, I, J, A, B>(i1 : Iso<S, T, I, J>)(i2 : Iso<I, J, A, B>) -> Iso<S, T, A, B> {
4146
return i1 • i2
4247
}
4348

44-
// Box iso
49+
/// MARK: Box iso
4550

51+
/// An isomorphism between Box and its underlying type.
4652
public func isoBox<A, B>() -> Iso<Box<A>, Box<B>, A, B> {
4753
return Iso(get: { $0.value }, inject: { Box($0) } )
4854
}
4955

50-
// Functor base types
56+
/// MARK: Functor base types
5157

58+
/// An isomorphism between the Identity Functor and its underlying type.
5259
public func isoId<A, B>() -> Iso<Id<A>, Id<B>, A, B> {
5360
return Iso(get: { $0.runId }, inject: { Id($0) })
5461
}
5562

63+
/// An isomorphism between the Const Functor and its underlying type.
5664
public func isoConst<A, B, X>() -> Iso<Const<A, X>, Const<B, X>, A, B> {
5765
return Iso(get: { $0.runConst }, inject: { Const($0) })
5866
}

‎Swiftz/IxCont.swift‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -13,67 +13,67 @@ public struct IxCont<R, O, A> {
1313
self.run = run
1414
}
1515

16-
public func map<B>(f: A -> B) -> IxCont<R, O, B> {
16+
public func map<B>(f : A -> B) -> IxCont<R, O, B> {
1717
return f <^> self
1818
}
1919

20-
public func imap<S>(f: R -> S) -> IxCont<S, O, A> {
20+
public func imap<S>(f : R -> S) -> IxCont<S, O, A> {
2121
return f <^^> self
2222
}
2323

24-
public func contramap<N>(f: N -> O) -> IxCont<R, N, A> {
24+
public func contramap<N>(f : N -> O) -> IxCont<R, N, A> {
2525
return f <!> self
2626
}
2727

28-
public func ap<E, B>(f: IxCont<E, R, A -> B>) -> IxCont<E, O, B> {
28+
public func ap<E, B>(f : IxCont<E, R, A -> B>) -> IxCont<E, O, B> {
2929
return f <*> self
3030
}
3131

32-
public func flatMap<E, B>(f: A -> IxCont<O, E, B>) -> IxCont<R, E, B> {
32+
public func flatMap<E, B>(f : A -> IxCont<O, E, B>) -> IxCont<R, E, B> {
3333
return self >>- f
3434
}
3535
}
3636

37-
public func run<R, O>(a: IxCont<R, O, O>) -> R {
37+
public func run<R, O>(a : IxCont<R, O, O>) -> R {
3838
return a.run(identity)
3939
}
4040

41-
public func pure<R, A>(x: A) -> IxCont<R, R, A> {
41+
public func pure<R, A>(x : A) -> IxCont<R, R, A> {
4242
return IxCont { $0(x) }
4343
}
4444

45-
public func <^> <R, O, A, B>(f: A -> B, a: IxCont<R, O, A>) -> IxCont<R, O, B> {
45+
public func <^> <R, O, A, B>(f : A -> B, a: IxCont<R, O, A>) -> IxCont<R, O, B> {
4646
return IxCont { k in a.run { k(f($0)) } }
4747
}
4848

49-
public func <^^> <R, S, O, A>(f: R -> S, a: IxCont<R, O, A>) -> IxCont<S, O, A> {
49+
public func <^^> <R, S, O, A>(f : R -> S, a: IxCont<R, O, A>) -> IxCont<S, O, A> {
5050
return IxCont { f(a.run($0)) }
5151
}
5252

53-
public func <!> <R, N, O, A>(f: N -> O, a: IxCont<R, O, A>) -> IxCont<R, N, A> {
53+
public func <!> <R, N, O, A>(f : N -> O, a: IxCont<R, O, A>) -> IxCont<R, N, A> {
5454
return IxCont { k in a.run { f(k($0)) } }
5555
}
5656

57-
public func <*> <R, I, O, A, B>(f: IxCont<R, I, A -> B>, a: IxCont<I, O, A>) -> IxCont<R, O, B> {
57+
public func <*> <R, I, O, A, B>(f : IxCont<R, I, A -> B>, a: IxCont<I, O, A>) -> IxCont<R, O, B> {
5858
return IxCont { k in f.run { g in a.run { k(g($0)) } } }
5959
}
6060

61-
public func >>- <R, I, O, A, B>(a: IxCont<R, I, A>, f: A -> IxCont<I, O, B>) -> IxCont<R, O, B> {
61+
public func >>- <R, I, O, A, B>(a : IxCont<R, I, A>, f: A -> IxCont<I, O, B>) -> IxCont<R, O, B> {
6262
return IxCont { k in a.run { f($0).run(k) } }
6363
}
6464

65-
public func join<R, I, O, A>(a: IxCont<R, I, IxCont<I, O, A>>) -> IxCont<R, O, A> {
65+
public func join<R, I, O, A>(a : IxCont<R, I, IxCont<I, O, A>>) -> IxCont<R, O, A> {
6666
return IxCont { k in a.run { $0.run(k) } }
6767
}
6868

69-
public func shift<R, I, J, O, A>(f: (A -> IxCont<I, I, O>) -> IxCont<R, J, J>) -> IxCont<R, O, A> {
69+
public func shift<R, I, J, O, A>(f : (A -> IxCont<I, I, O>) -> IxCont<R, J, J>) -> IxCont<R, O, A> {
7070
return IxCont { k in run(f { pure(k($0)) }) }
7171
}
7272

73-
public func reset<R, O, A>(a: IxCont<A, O, O>) -> IxCont<R, R, A> {
73+
public func reset<R, O, A>(a : IxCont<A, O, O>) -> IxCont<R, R, A> {
7474
return pure(run(a))
7575
}
7676

77-
public func callCC<R, O, A, B>(f: (A -> IxCont<O, O, B>) -> IxCont<R, O, A>) -> IxCont<R, O, A> {
77+
public func callCC<R, O, A, B>(f : (A -> IxCont<O, O, B>) -> IxCont<R, O, A>) -> IxCont<R, O, A> {
7878
return IxCont { k in (f { x in IxCont { _ in k(x) } }).run(k) }
7979
}

0 commit comments

Comments
 (0)