I hereby claim:
- I am JadenGeller on github.
- I am jaden (https://keybase.io/jaden) on keybase.
- I have a public key whose fingerprint is CD7E 9E0B AE92 1CDB EBD9 3AFB 5989 E3D5 A174 FDD4
To claim this, I am signing this object:
I hereby claim:
To claim this, I am signing this object:
/* | |
* attempt takes a function that does not accept optional values | |
* and returns a new function that will work as usual with non-optional values | |
* and return nil when passed an optional value | |
*/ | |
func attempt<T,U>(f: T -> U)-> T? -> U? { | |
return { y in | |
if let x = y { | |
return f(x) |
/* | |
* coalesce takes in a list of optional values | |
* and returns the first one that is not nil | |
*/ | |
func coalesce<T>(all: @autoclosure () -> T? ...) -> T? { | |
for f: () -> T? in all { | |
if let x = f() { return x } | |
} | |
return nil |
/* | |
* Returns the default value whenever the primary value is nil | |
* Otherwise returns the primary value | |
*/ | |
func unwrap<T>(primaryValue: T?, defaultValue: T) -> T { | |
if let value = primaryValue { return value } | |
else { return defaultValue } | |
} | |
// Examples |
#import <objc/runtime.h> | |
Class randomClass(){ | |
int numClasses = objc_getClassList(NULL, 0); | |
Class *classes = calloc(sizeof(Class), numClasses); | |
objc_getClassList(classes, numClasses); | |
Class randomClass = *(classes + arc4random_uniform(numClasses)); | |
free(classes); | |
return randomClass; | |
} |
/* | |
* Allows you to offset offset a generator | |
* and loop back around to the initial values | |
*/ | |
struct OffsetGenerator<G : GeneratorType> : GeneratorType { | |
var generator: G | |
var skipped = Array<G.Element>() | |
init(generator: G, var offset: Int){ | |
self.generator = generator |
// Imagine we have a function that curries | |
// That is, multiply takes in an integer a | |
// and returns a fuction that takes in another | |
// integer b that will return a * b | |
func multiply(a: Int) -> Int -> Int { | |
println("I got the first thing") | |
return { b in | |
println("I got the second thing") | |
return a * b | |
} |
/* | |
* Allows you to limit the count of a sequence | |
*/ | |
extension SequenceType { | |
func take(count: Int) -> FiniteSequence<Generator.Element> { | |
return FiniteSequence(backing: AnySequence(self), count: count) | |
} | |
} |
// Let's start with an example | |
var c = 0 | |
// Inside a jump block, calling the restart function starts over | |
// and calling the skip function exists the block | |
jump { restart, skip in | |
for i in 1...4 { | |
println("c: \(c); i: \(i)") | |
if c == 4 { skip() } | |
else if i == 3 { c++; restart() } |
// We will show how long jumps can be used within Swift | |
// Create jump and set it's position | |
let start = Jump() | |
setjmp(start.line) // Sets start's line to the current line | |
println("HI") // -> "Hi" -> "Hi" -> "Hi" -> ... (prints forever) | |
longjmp(start.line, 0) // Jumps back to start's line, e.g. setjmp(start.line) |