public enum Maybe<T> : ExpressibleByNilLiteral {
    case none, some(T)
    
    public init() { self = .none }
    public init(_ s: T) { self = .some(s) }
    public init(nilLiteral: ()) { self = .none }
    
    func map<U>(_ f: (T) -> U) -> Maybe<U> {
        switch self {
        case .none : return .none
        case .some(let x) : return .some(f(x))
        }
    }
}

func pure<A>(_ x: A) -> Maybe<A> {
    return Maybe(x)
}

infix operator >>= { associativity left }
func >>= <A,B> (m: Maybe<A>, f: (A) -> Maybe<B>) -> Maybe<B> {
    switch m {
    case .none : return .none
    case .some(let m) : return f(m)
    }
}

struct Room { let length: Int, width: Int }
struct Residence { let rooms: [Room] }
struct Person { let name: String, residence: Maybe<Residence> }

func livingSpace(_ person: Maybe<Person>) -> Maybe<Int> {
    return person >>= { $0.residence }
        >>= { pure($0.rooms.map { $0.length * $0.width }.reduce(0, combine: +)) }
}