macbaszii

func plusThree(addend: Int) -> Int {
  return addend + 3
}

Optional.Some(2).map(plusThree)
// => .Some(5)

macbaszii

Optional.Some(2).map { $0 + 3 }
// => .Some(5)

macbaszii

func map<U>(f: T -> U) -> U? {
  switch self {
  case .Some(let x): return f(x)
  case .None: return .None
}

macbaszii

Optional.None.map { $0 + 3 }
// => .None

macbaszii

let post = Post.findByID(1)
if post != nil {
  return post.title
} else {
  return nil
}

macbaszii

findPost(1).map(getPostTitle)

macbaszii

infix operator <^> { associativity left }

func <^><T, U>(f: T -> U, a: T?) -> U? {
  return a.map(f)
}

getPostTitle <^> findPost(1)

macbaszii

map({ $0 + 2 }, { $0 + 3 })
// => ???

macbaszii

typealias IntFunction = Int -> Int

func map(f: IntFunction, _ g: IntFunction) -> IntFunction {
  return { x in f(g(x)) }
}

let foo = map({ $0 + 2 }, { $0 + 3 })
foo(10)
// => 15

macbaszii

extension Optional {
  func apply<U>(f: (T -> U)?) -> U? {
    switch f {
      case .Some(let someF): return self.map(someF)
      case .None: return .None
    }
  }
}

extension Array {