[함수형 프로그래밍] Chapter4.예외를 이용하지 않은 오류 처리

[enochyeon]

목표

• 표준라이브러리에 있는 Option, Either를 구현해보며 오류처리 방법 이해

4.1 예외의 장단점

목록 4.1

// 참조 투명성 테스트 코드
def failingFn(i: Int): Int = {
  val y: Int = throw new Exception("fail!")
  try {
    val x = 42 + 5
    x + y
  }
  catch { case e: Exception => 43 }
}

def failingFn2(i: Int): Int = {
  try {
    val x = 42 + 5
    x + ((throw new Exception("fail!")): Int)
  }
  catch { case e: Exception => 43 }
}

println(failingFn(12))
//println(failingFn2(12))

https://scalafiddle.io/sf/YbyNapO/0

참조 투명성

표현식	비고
참조에 투명	문맥에 의존하지 않으며 지역적으로 추론 가능
참조에 투명하지 않음	문맥에 의존적이고 전역적 추론 필요

예외의 주된 문제

• 참조 투명성을 위반하고 문맥 의존성을 도입한다.
  • (해석) 쉽게 이해 불가. 코드 복잡해짐.
• 형식에 안전하지 않다.
  • (해석) 미리 처리 방식을 알기 어려움.

4.2 예외의 가능한 대안들

대안1. 별도의 값 반환

def mean(xs: Seq[Double]): Double = 
    if (xs.isEmpty)
        throw new ArithmeticException("mean of empty list!")
    else
        xs.sum / xs.length

• 예
  • NaN, null, ...
• 단점
  • 오류가 드러나지 않음
  • 반환값을 점증하는 판박이 코드 양산
  • 다형적 코드에 적용 불가(경계값을 결정해야하는 경우)
  • 호출자 작업 불편

대안2. 행동을 알려주는 인수 전달

def mean_1(xs: IndexedSeq[Double], onEmpry: Double): Double = 
    if (xs.isEmpty)
        onEmpty
    else
        xs.sum / xs.length

• 단점
  • 호출자가 처리방식을 알고 있어야 함
  • 큰 계산과정에서 onEmpty만으로 유연성을 얻기 힘듬

4.3 Option 자료 형식

sealed trait Option[+A]
case class Some[+A](get: A) extends Option[A]
case object None extends Option[Nothing]

def mean_1(xs: Seq[Double]): Option[Double] = 
    if (xs.isEmpty)
        None
    else
        Some(xs.sum / xs.length)

• 별도의 값 반환하는 방식을 객체로 풀어낸 것 같은..?

4.3.1 Option의 사용 패턴

사용 예시

• Map에서 key 찾기
• 목록과 반복 가능 자료 형식

Option에 대한 기본적인 함수를

• List와 비슷
• 차이점은 Option은 최대 하나의 원소만 담을 수 있음
• trait을 사용하여 구현해봄

trait Option[+A] {
    def map[B](f: A => B): Option[B]
    def flatMap[B](f: A => Option[B]): Option[B]
    def getOrElse[B >: A](default: => B): B
    def orElse[B >: A](ob: => Option[B]): Option[B]
    def filter(f: A => Boolean): Option[A]
}

• getOrElse, orElse
  • 인수 형식 B는 함수에서 실제로 쓰일 때까지는 평가되지 않음(뭔말? #12에 취급. 일단 스킵)
• B >: A
  • B가 반드시 A와 같거나 A의 상위형식(supretype)이어야 함을 뜻함

기본적인 Option 참수들의 용례

• (책의 예시 확인)
• 오류를 명시적으로 검사하지 않음
• 일찍 None을 반환하여 나머지 호출 취소

정리

• 보통(?)의 값으로 반환하여 코드짜기 편함
• 고차함수를 사용하여 오류 처리 논리 통합과 격리
• 타입 검증을 하여 안정성 확보

4.3.2 예외 지향적 API의 Option 합성과 승급, 감싸기

• Option으로 온통 도배되지 않을지 우려?
• 보통 함수를 Option에 대해 작용하는 함수로 승급(lift) 가능
• (해석) 기존 코드를 모두 수정할 필요는 없고 wrapping 하는 방식

def lift[A,B](f: A => B): Option[A] => Option[B] = _ map f

var abs0: Option[Double] => Option[Double] = lift(math.abs)

for-comprehension(함축)

def map2[A,B,C](a: Option[A], b: Option[B])(f: (A, B) => C): Option[C] =
    a flatMap (aa => 
        b map (bb =>
            f(aa, bb)))

def map2[A,B,C](a: Option[A], b: Option[B])(f: (A, B) => C): Option[C] =
    for {
        aa <- a
        bb <- b
    } yield f(aa, bb)

• {} 블럭 안에 묶음(binding) 표현
• yield 내에서 좌변의 값 사용 가능
• 컴파일러는 묶음들을 flatMap으로 전개하고 마지막 묶음과 yield는 map 호출로 변환한다.

4.4 Either 자료 형식

• Option 단점
  • 예외 발생 시 정보 제공을 못함. 단지 None 반환.

sealed trait Either[+E, +A]
case class Left[+E](value: E) extends Either[E, Nothing]
case class Right[+A](value: A) extends Either[Nothing, A]

• 두 경우 모드 값을 가지는 것이 Option과의 차이
• 분리합집합(disjoint union; 서로 소 합집합)
• Right 성공
• Left 실패

def mean(xs: IndexedSeq[Double]): Either[String, Double] =
    if (xs.isEmpty)
        Left("mean of empty list!")
    else
        Right(xs.sum / xs.length)

def safeDiv(x: Int, y: Int): Either[Exception, Int] =
    try Right(x / y)
    catch {case e: Exception => Left(e)}

def Try[A](a: => A):Either[Exception, A] =
    try Right(a)
    catch {case e: Exception => Left(e)}

def parseInsuranceRateQuote(
    age: String, numberOfSpeedingTickets: String): Either[Exception, Double] =
    for {
        a <- Try {age.toInt}
        tickets <- Try {numberOfSpeedingTickets.toInt}
    } yield insuranceRateQuote(a, tickets)

4.5 요약

• 예외를 보통의 값으로 표현
• 고차 함수를 이용해서 오류 처리 및 전파하는 패턴을 캡슐화
• 비엄격(non-strict) 함수 언급
  • orElse, getOrElse, Try