[함수형 프로그래밍] Maybe & Either

Maybe

• 값의 부재 가능성을 표현
• funtor이자 monad
• 값이 nil로 변할 가능성이 없는 transform의 경우 map사용(functor)
• 값이 nil로 변할 가능성이 있는 transform의 경우 flapMap사용(monad)
• Optional 이 곧 maybe

enum Maybe<A> {
    case None
    case Some(A)

    static func pure<B>(_ value: B) -> Maybe<B> {
        return .Some(value)

    func flapMap<B>(_ f: (A) -> Maybe<B>) -> Maybe<B> {
        switch self {
        case .None:
            return .None
        case .Some(let value):
            return f(value)
        }
    }
    func map<B>(f: (A) -> B) -> Maybe<B> {
        reutrn self.flatMap { type(of: self).pure(f($0)) }
    }
}

Either

• 어떤 값이 두가지 타입을 가질 수 있는 경우를 표현
• 우리가 자주 사용하는Result가 Either

enum Either <R, L> {
    case right(R)
    case left(L)
}

• right는 Int, left를 가짐

// right를 사용하는 경우
var either: Either<Int, String> = .right(3)
swithch either {
case .right(let r):
    print(r)
case .left(let l):
    print(l)
}

• Optional로 예외 처리 할 수 있지만 optional은 실패했음을 표현할 수 있지만 어떤 에러가 발생했는지 알 방법이 없음

enum Either<A, B> {
    case Left(A)
    case Right(B)

    static func pure<C>(_ value: C) -> Either<A, C> {
        return Either<A, C>.Right(value)
    }

    func flapMap<D>(_ f: (B) -> Either<A, D>) -> Either<A, D> {
        switch self {
        case .Left (let x):
            return Either<A, D>.Left(x)
        case .Right(let x):
            return f(x)
        }
    }

    func map<C>(f: (B) -> C) -> Either<A, C> {
        return self.flapMap { Either<A, C>.pure(f($0)) }
    }
}