func allItemsMatch<C1: Container, C2: Container where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>(a: C1, b: C2) { ... } // book

 let x = if y { 4 } else { 5 }  // Not supported

// INTRO 
let sum = { $0 + $1 }
// or
 let sum = { (x,y) in x + y }
// or
 let sum = { (x: Int, y: Int) -> Int in x + y }

 int (*sum)(int x, int y)

 sum(1, 2) // = 3

 sum(1, 2) // = 3

 enum Person { case Man; case Woman } // define an enum
 let m: Person = .Man // intro1
 let w = Person.Woman // intro2

 typedef enum {MAN, WOMAN} Person;
 Person m = MAN; // intro1
 Person w = WOMAN; // intro2

 switch (person) { case .Man:
     println("I'm a man")
   case .Woman:
     println("I'm a woman") }

 if (person == MAN) { printf("I'm a man"); } else { printf("I'm a woman"); }

 enum ChurchNumeral { case Z; case S(ChurchNumeral); } // crashes :(

 func plus(x: ChurchNumeral, y: ChurchNumeral) {
   if x == Z {      return y   } else {      return S(plus(x.predecessor(), y))   } }

func plus(x: ChurchNumeral, y: ChurchNumeral) {
   switch (x) {     case Z:       return y     case S(let x_):       return S(plus(x_, y))   } }

• You need to store the URL for some image in an object
  
• Sometimes you make the object when you have the real URL
  
• Sometimes you make the object when you only have the S3 key and bucket 

  var url: String?
  var bucket: String?
  var key: String?

  func realUrl() -> String {
    return url ? url : computeUrl(key, bucket)
  }

 enum S3Info { // we either have BOTH the key and the bucket, OR the url
   case BucketKey(String, String)
   case URL(String)
 }
 
 @lazy var url: String = {
   switch (self._s3Info) {
   case .BucketKey(let bucket, let key): 
     // if we have BOTH the key and the bucket, use them now. No blindness
     return computeOnBucketKey(bucket, key)
   case .URL(let u):
     return u
   }
 }()

 var x: String = "hello" // x can change (var) but can NEVER be nil 
 // Intro
 var xOpt: String? = "hello" // y CAN be nil
 
 // Elimination
 if let v = xOpt {
   // v can NEVER be nil!
 } else {
   // xOpt was nil!
 }

 let xOpt: String? = "hello"

 if xOpt != nil {
   println(xOpt!)
 }

 func arrayByAddingObject(_ anObject: AnyObject!) -> [AnyObject]!

 let xOpt: String? = "hello" // regular optional

 let yOpt: Optional<String> = .None
 let zOpt: Optional<String> = .Some("hello") // capital "O" Optional

 var storedProp: Optional<String> = .None

 // extending Optional puts methods on optional as well!
 extension Optional {
   func getOrElse(els: @auto_closure () -> T) -> T {
     switch (self) {
     case .None:
       return els()
     case .Some(let t):
       return t
     }
   }
 }

 let xOpt: Int? = 10
 let yOpt: Int? = nil
 
 let z = xOpt.getOrElse(0) + yOpt.getOrElse(1)

 func getOrElse(els: @auto_closure () -> T) -> T

 enum Result<T,E> {
   case Success(T)
   case Error(E)
 }

 enum Tree<T> {
   case Leaf(T)
   case Node(Tree<T>, T, Tree<T>)
 }

 class Dog {
   class var sharedInstance: Dog {
     struct Singleton {
       static let instance = Dog()
     }
     return Singleton.instance
   }
 }

 // Usage
 Dog.sharedInstance

 var library: ALAssetsLibrary? = nil

 func doSomething() {
   if library == nil {
     library = ALAssetsLibrary(); library.something()
   }
 }

 @lazy var library: ALAssetsLibrary = ALAssetsLibrary()

 func doSomething() {
   library.something() // initialized here magically
 }

 // Bridging Header
 #import "shared/utils/UserModel.h"
 ...

 import CoreGraphics
 import Foundation

 failureBlock: { err in
   dispatch_semaphore_signal(sema)
   return
 }