17 실패를 설계하기

17.1 경계와 안쪽#

프로그램에는 바깥에서 값이 들어오는 자리가 있다. 프로그램 인자, 파일 내용, 네트워크에서 온 바이트, 사용자의 입력이다. 그 값에는 아무 약속도 없다. 반대로 한 번 검사를 통과한 값이 흘러 다니는 안쪽이 있다.

설계의 첫 원칙은 이 둘을 가르는 것이다.

module parse .
rem run: parse_u16 [52,50]
rem run: parse_u16 []
rem run: parse_u16 [52,120]
rem run: parse_u16 [55,48,48,48,48]
rem run: port_or_default [56,48]
rem run: port_or_default [120]

enum parse_error do
  empty .
  not_digit .
  too_big .
end

fn is_digit input c u8 . output bool .
do
  return and (ge c 48) (le c 57) .
end

rem 바깥에서 온 바이트 — 무엇이든 올 수 있으므로 실패는 값이다
fn parse_u16 input s slice u8 . output result u16 parse_error .
  errors empty eq (len s) 0 .
  errors not_digit .
  errors too_big .
do
  guard gt (len s) 0 . else return error empty .
  var acc u64 be 0 .
  for c s do
    guard is_digit c . else return error not_digit .
    set acc (add (mul acc 10) (widen u64 (sub c 48))) .
    guard le acc 65535 . else return error too_big .
  end
  return ok (narrow u16 acc) .
end

rem 이 층은 «왜» 가 필요 없다 — 없으면 기본값을 쓴다
fn port_or_default input s slice u8 . output u16 .
do
  let r result u16 parse_error be parse_u16 s .
  guard not (is_error r) . else return 8080 .
  return ok_value r .
end

$ lowentc --run parse_u16 parse.low [52,50]
parse_u16([52,50]) = ok 42
  arg0 (written) = [52,50]
$ lowentc --run parse_u16 parse.low []
parse_u16([]) = err empty
  arg0 (written) = []
$ lowentc --run parse_u16 parse.low [52,120]
parse_u16([52,120]) = err not_digit
  arg0 (written) = [52,120]
$ lowentc --run parse_u16 parse.low [55,48,48,48,48]
parse_u16([55,48,48,48,48]) = err too_big
  arg0 (written) = [55,48,48,48,48]
$ lowentc --run port_or_default parse.low [56,48]
port_or_default([56,48]) = 80
  arg0 (written) = [56,48]
$ lowentc --run port_or_default parse.low [120]
port_or_default([120]) = 8080
  arg0 (written) = [120]

parse_u16 은 경계다. 바이트는 비어 있을 수도, 숫자가 아닐 수도, 너무 클 수도 있다. 셋 모두 고칠 수 있는 실패이므로 result 로 돌려준다. 계약으로 “숫자만 주시오” 라고 요구하는 것은 틀린 설계다 — 부르는 쪽은 바이트를 받자마자 이 op 에 넘기므로, 요구를 지킬 방법이 없다.

값이 어디서 와서 어디로 가는지 그리면 이렇다.

 바깥 (약속 없음)         경계                 안쪽 (이미 걸렀다)
 인자 · 파일 · 바이트 ──▶ parse_u16 ── ok ──────▶ slot_of …
                          result + errors      requires · range · newtype
                             │ error
                             ▼
                          부르는 층이 무엇을 할지 고른다

17.2 오류 열거형을 나누는 기준#

오류 갈래는 부르는 쪽이 다르게 행동할 경우마다 하나씩 둔다. empty·not_digit·too_big 을 가른 것은 화면에 다른 안내를 보여 줄 수 있기 때문이다. 부르는 쪽이 모두 같은 일을 한다면 갈래를 합친다. 갈래가 많을수록 match 로 다루는 쪽의 짐이 는다.

반대로 한 op 이 서로 관계없는 층의 오류를 모두 담는 거대한 열거형은 피한다. 파일 오류와 파싱 오류와 설정 오류가 한 열거형에 섞이면, 머리의 errors 절이 그 op 이 실제로 낼 수 있는 것보다 넓은 그림을 그리게 되고, 일어날 수 없는 오류 선언은 번역이 거절한다(14장).

17.3 층을 올라가며#

실패를 받은 층은 둘 중 하나를 한다. 넘기거나, 그 자리에서 다루거나.

module layers .
rem run: main

enum config_error do
  bad_port .
  port_zero .
end

rem 안쪽 불변식 — 부르는 쪽이 이미 걸렀어야 하는 것은 계약이다
fn slot_of input port u16 . input slots u64 . output u64 .
  requires gt slots 0 .
do
  return mod (widen u64 port) slots .
end

rem 바깥 입력 — 틀릴 수 있는 것은 result 다
fn check_port input port u16 . output result u16 config_error .
  errors port_zero eq port 0 .
do
  guard ne port 0 . else return error port_zero .
  return ok port .
end

fn pick_slot input port u16 . output result u64 config_error .
  errors port_zero eq port 0 .
do
  let p u16 be try check_port port .
  return ok (slot_of p 16) .
end

proc main input out cap io . output u8 . effects io .
do
  let r result u64 config_error be pick_slot 8080 .
  guard not (is_error r) . else do
    let n u64 be write_out out 1 "bad port\n" .
    return 1 .
  end
  let m u64 be write_out out 1 "slot ok\n" .
  return narrow u8 (ok_value r) .
end

$ lowentc --run main layers.low
slot ok
main() = 0

• slot_of 는 안쪽이다. 슬롯 수가 0 이면 나머지 연산이 멈추지만, 그것은 부르는 쪽의 잘못이므로 requires gt slots 0 . 으로 적었다.
• check_port 는 경계에 가깝다. 0 번 포트는 설정이 틀린 것이고 고칠 수 있으므로 result 다.
• pick_slot 은 try 로 실패를 위로 넘긴다. 자기도 같은 오류를 errors 에 적었다. 성공한 뒤에는 p 가 0 이 아님을 알므로 안쪽 op 을 부른다.
• main 은 가장 바깥 층이다. 더 넘길 곳이 없으므로 실패를 다룬다 — 메시지를 쓰고 종료 코드 1 을 돌려준다.

port 가 0 일 때 실패가 올라가는 길을 그리면 이렇다. 내려갈 때는 부르고, 올라올 때는 넘기거나 다룬다.

 main ─────────────────────────  다룬다: "bad port" 를 쓰고 1 을 돌려준다
  │  ▲ error port_zero
  ▼  │
 pick_slot ────────────────────  넘긴다: try 가 그대로 위로
  │  ▲ error port_zero      │
  ▼  │                      ▼ 성공한 뒤에만
 check_port                 slot_of
 (경계: result)             (안쪽: requires gt slots 0)

규칙으로 정리하면, 넘길 수 있는 가장 가까운 층이 다룰 수 있으면 넘기지 말고, 다룰 수 없으면 넘긴다. try 는 넘기는 비용을 한 낱말로 줄였지만, 넘긴다는 사실은 부르는 쪽의 errors 절에 남는다.

17.4 정보를 버려도 되는 자리#

port_or_default 는 실패의 이유가 필요 없다. 무엇이 틀렸든 기본 포트 8080 을 쓴다. 이런 층에서는 result 를 묻고 버리거나, try … else_none 으로 option 으로 바꾸어 value_or 를 쓴다. 정보를 버리는 것은 그 층이 결정할 일이다. 아래 층이 미리 option 으로 버려 두면, 이유가 필요한 위 층이 되찾을 길이 없다. 그러니 버리는 것은 가능한 한 위에서 한다.

17.5 panic 을 써도 되는 자리#

panic 은 복구할 수 없는 상태를 만났을 때 쓴다. 판단 기준은 “이 상태를 어느 층이 다룰 수 있는가” 다.

• 프로그램의 불변식이 깨졌다(내부 표가 손상되었다). 어느 층도 올바른 답을 낼 수 없으므로 멈춘다.
• 계속 가면 더 큰 피해가 난다(검증에 실패한 데이터를 기록하려 한다).

반대로 사용자의 입력이 틀린 것, 파일이 없는 것, 연결이 끊긴 것은 panic 할 일이 아니다. 어느 층인가 다룰 수 있다. 그리고 panic 은 효과이므로, 쓰는 순간 그 op 과 부르는 모든 op 의 머리에 effects panic 이 번진다 (15장). 그 비용이 panic 을 아껴 쓰게 만든다.

17.6 흔한 실수#

module mistake_panicinput .
rem run: parse_or_die [52,50]
rem trap: parse_or_die [52,120]

rem ✘ 사용자가 잘못 친 한 글자에 프로그램 전체가 멈춘다
proc parse_or_die input s slice u8 . output u64 . effects panic .
do
  var acc u64 be 0 .
  for c s do
    if or (lt c 48) (gt c 57) . do panic "not a digit" . end
    set acc (add (mul acc 10) (widen u64 (sub c 48))) .
    if gt acc 65535 . do panic "too big" . end
  end
  return acc .
end

$ lowentc --run parse_or_die mistake_panicinput.low [52,50]
parse_or_die([52,50]) = 42
  arg0 (written) = [52,50]
$ lowentc --run parse_or_die mistake_panicinput.low [52,120]
== ir diagnostics (1) ==
0:0 E-VM-PANIC: the program called `panic` — this is an unrecoverable stop, and it is NOT a contract violation (the code chose to stop, it did not break a promise)

module mistake_dropwhy .
rem run: explain []
rem run: explain [120]

enum parse_error do
  empty .
  not_digit .
end

fn parse_digit input s slice u8 . output result u8 parse_error .
  errors empty eq (len s) 0 .
  errors not_digit .
do
  guard gt (len s) 0 . else return error empty .
  let c u8 be index s 0 .
  guard and (ge c 48) (le c 57) . else return error not_digit .
  return ok (sub c 48) .
end

rem ✘ 아래 층이 미리 이유를 버렸다
fn digit_or_none input s slice u8 . output option u8 .
do
  return try (parse_digit s) else_none .
end

rem 위 층은 빈 입력과 숫자 아닌 입력을 다르게 안내하고 싶지만 둘 다 0 만 본다
fn explain input s slice u8 . output u8 .
do
  let d option u8 be digit_or_none s .
  guard is_some d . else return 0 .
  return 9 .
end

$ lowentc --run explain mistake_dropwhy.low []
explain([]) = 0
  arg0 (written) = []
$ lowentc --run explain mistake_dropwhy.low [120]
explain([120]) = 0
  arg0 (written) = [120]

module dropwhy_fixed .
rem run: explain []
rem run: explain [120]
rem run: explain [55]

enum parse_error do
  empty .
  not_digit .
end

fn parse_digit input s slice u8 . output result u8 parse_error .
  errors empty eq (len s) 0 .
  errors not_digit .
do
  guard gt (len s) 0 . else return error empty .
  let c u8 be index s 0 .
  guard and (ge c 48) (le c 57) . else return error not_digit .
  return ok (sub c 48) .
end

rem 이유를 끝까지 들고 올라와, 필요한 층에서 가른다
fn explain input s slice u8 . output u8 .
do
  match parse_digit s do
    case ok v . return 9 .
    case error e . do
      rem 오류 값에 이름을 묶고, 그 열거형을 한 번 더 가른다
      match e do
        case empty . return 1 .
        case not_digit . return 2 .
      end
    end
  end
end

$ lowentc --run explain dropwhy_fixed.low []
explain([]) = 1
  arg0 (written) = []
$ lowentc --run explain dropwhy_fixed.low [120]
explain([120]) = 2
  arg0 (written) = [120]
$ lowentc --run explain dropwhy_fixed.low [55]
explain([55]) = 9
  arg0 (written) = [55]

오류 갈래는 case error <갈래이름> 으로 곧바로 가른다.

module errvariant .
rem run: explain []
rem run: explain [120]
rem run: explain [53]

enum parse_error do
  empty .
  not_digit .
end

fn parse_digit input s slice u8 . output result u8 parse_error .
  errors empty eq (len s) 0 .
  errors not_digit .
do
  guard gt (len s) 0 . else return error empty .
  let c u8 be index s 0 .
  guard and (ge c 48) (le c 57) . else return error not_digit .
  return ok (sub c 48) .
end

fn explain input s slice u8 . output u8 .
do
  rem `case error <갈래>` 의 이름이 선언된 갈래면 그 갈래만 받는다
  match parse_digit s do
    case ok v . return 9 .
    case error empty . return 1 .
    case error not_digit . return 2 .
  end
end

$ lowentc --run explain errvariant.low []
explain([]) = 1
  arg0 (written) = []
$ lowentc --run explain errvariant.low [120]
explain([120]) = 2
  arg0 (written) = [120]
$ lowentc --run explain errvariant.low [53]
explain([53]) = 9
  arg0 (written) = [53]

case error 뒤의 이름이 선언된 갈래면 그 갈래만 받는다. 선언된 갈래가 아니면 오류 값 전체를 그 이름에 묶는다(case error e) — 이름 하나로 두 가지 뜻을 쓰는 셈이지만, 가르는 규칙은 match 의 다른 자리와 같다: 맨 이름이 갈래면 갈래다(7장). 갈래마다 적으면 망라 검사가 갈래 하나가 빠진 것을 잡는다. 이름으로 묶으면 그 하나가 모든 오류를 받으므로 잡을 것이 없다.

module mistake_dropresult .
rem expect: W-RESULT-DISCARD

enum config_error do
  port_zero .
end

fn check_port input port u16 . output result u16 config_error .
  errors port_zero eq port 0 .
do
  guard ne port 0 . else return error port_zero .
  return ok port .
end

proc main input out cap io . output u8 . effects io .
do
  rem ✘ 검사의 결과를 문장으로 버렸다 --- 포트가 0 인데 "started" 가 나온다
  check_port 0 .
  let n u64 be write_out out 1 "started\n" .
  return 0 .
end

$ lowentc --check mistake_dropresult.low
mistake_dropresult.low:18:0 W-RESULT-DISCARD: this op returns a `result` — it says failure is a VALUE — and the value is dropped here, so a failure leaves no trace at all. Bind it and look at it (`let r … be …` then `is_error`), forward it (`try`), or say in the code why the failure does not matter

17.7 이 장의 문법 한눈에#