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.
| // | |
| // Free.swift | |
| // Swift_Extras | |
| // | |
| // Created by Robert Widmann on 9/19/14. | |
| // Copyright (c) 2014 Robert Widmann. All rights reserved. | |
| // | |
| import Foundation |
| // Playground - noun: a place where people can play | |
| public func id<A>(x : A) -> A { | |
| return x | |
| } | |
| public func error<A>(x : String) -> A { | |
| assert(false, x) | |
| } |
| #!/bin/sh | |
| # Combined all static libaries in the current directory into a single static library | |
| # It is hardcoded to use the i386, armv7, and armv7s architectures; this can easily be changed via the 'archs' variable at the top | |
| # The script takes a single argument, which is the name of the final, combined library to be created. | |
| # | |
| # For example: | |
| # => combine_static_libraries.sh combined-library | |
| # | |
| # Script by Evan Schoenberg, Regular Rate and Rhythm Software |
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. As of Swift 1.2 and Xcode 6.3, this is no longer very fragile.
Unfortunately, the compiler cannot verify the types when passing a function to (>>=). We have to wrap the function in a closure and call it with an explicit argument to compile.
optionalDoubles >>= squareRoot // doesn't compile
optionalDoubles >>= { squareRoot($0) } // compiles| {-# LANGUAGE GADTs #-} | |
| {-# LANGUAGE FlexibleContexts #-} | |
| {-# LANGUAGE TupleSections #-} | |
| {-# LANGUAGE UndecidableInstances #-} | |
| {-# LANGUAGE ScopedTypeVariables #-} | |
| {-# LANGUAGE RankNTypes #-} | |
| import Control.Applicative | |
| import Control.Comonad | |
| import Data.Bifunctor |
#Every Single Option Under The Sun
| extension Array { | |
| var powerSet: [[Element]] { | |
| guard !isEmpty else { return [[]] } | |
| return Array(self[1...]).powerSet.flatMap { [$0, [self[0]] + $0] } | |
| } | |
| } | |
| print([1,2,3,4].powerSet) // -> [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3], [4], [1, 4], [2, 4], [1, 2, 4], [3, 4], [1, 3, 4], [2, 3, 4], [1, 2, 3, 4]] |
Note: < i=OS 5.1 use
prefs:. > 5.1 useapp-settings:
A type whose values can safely be passed across concurrency domains by copying.
What is an effect, anyway? In this hypothetical language (which I’ll call effecta because it sounds cool), an effect should be any change to any state. This sounds generic, but a generic foundation allows us to apply a question to everything we do to make sure it respects the symmetries of our system. Our question in this case will be: “is this thing an effect?”, and the answer will be “it is an effect if and only if it is a change to some state”.
