| @infix func * <A,B,C> (g: B -> C, f: A -> B) -> (A) -> C { | |
| return {(x: A) -> C in | |
| return g(f(x)) | |
| } | |
| } | |
| var f = {(x: Int) -> Float in | |
| return Float(x * x) / 2.0 | |
| } |
| protocol Functor { | |
| func fmap <A, B> (Self<A>, A -> B) -> Self<B> | |
| // ^ ERROR: Cannot specialize non-generic type '`Self`' | |
| } | |
| enum Maybe<A> : Functor { | |
| case Nothing | |
| case Just(A) | |
| func fmap<B>(x: Maybe<A>, f: A -> B) -> Maybe<B> { |
| func compact <A> (xs: [A?]) -> [A] { | |
| return xs.reduce([]) { accum, x in | |
| if let x = x { | |
| return accum + [x] | |
| } | |
| return accum | |
| } | |
| } | |
| var xs: [Int?] = [1, 2, nil, 3] |
| vWelcome to Swift! Type :help for assistance. | |
| a 1> var x:String | |
| x: String = { | |
| core = { | |
| _baseAddress = Builtin.RawPointer = 0x0000000000000000 | |
| _countAndFlags = 0 | |
| _owner = None | |
| } | |
| } | |
| 2> "test \(x)" |
| func f (x: Int) -> Int { | |
| return 1 + x + x*x | |
| } | |
| func f (x: Int) -> String { | |
| return "result = \(f(x) as Int)" | |
| } | |
| // awesome! | |
| var x: Int = f(2) // 7 |
| func unit <A> (x: A) -> A? { | |
| return Optional.Some(x) | |
| } | |
| func unit <A> (x: A) -> [A] { | |
| return [x] | |
| } | |
| // hypothetical examples | |
| func unit <A> (x: A) -> Tree<A> { |
Copy and paste the swift code below into a playground to experiment.
This is a very close emulation of Functor and Monad typeclasses in swift. However, it is very fragile (i.e. easy to crash the compiler).
For example, instance methods of fmap will run fine, but attempting to use a globally defined fmap that acts on Functor types will cause a crash. Similarly for bind. Unfortunately this means we cannot define the nice infix operator versions of these functions.
| // ~(P ∨ Q) = ~P ∧ ~Q | |
| enum Nothing {} | |
| struct Not <A> { | |
| let not: A -> Nothing | |
| init (_ not: A -> Nothing) { self.not = not } | |
| } | |
| struct And <A, B> { |
Copy and paste this into a playground to play around.
| import Foundation | |
| /** | |
| Num typeclass | |
| */ | |
| protocol Num { | |
| func + (lhs: Self, rhs: Self) -> Self | |
| func - (lhs: Self, rhs: Self) -> Self | |
| func * (lhs: Self, rhs: Self) -> Self | |
| func / (lhs: Self, rhs: Self) -> Self |