2 첫 프로그램 — 짓고, 돌리고, 거절당하기

2.1 도구 짓기#

컴파일러의 이름은 lowentc 다. 저장소를 받은 뒤 impl/ 에서 짓는다. 필요한 것은 C23 을 아는 C 컴파일러(gcc 나 clang)와 make 뿐이다.

cd impl
make            # build/lowentc
make check      # 단위 시험과 표준 라이브러리 검사

make 가 끝나면 impl/build/lowentc 가 생긴다. 이 책의 명령은 그것이 경로에 있다고 치고 lowentc 로 적는다.

2.2 hello, entropy#

가장 작은 출력 프로그램이다.

module hello .
rem run: main

proc main input out cap io . output u8 . effects io . do
  return narrow u8 (write_out out 1 "hello, entropy!\n") .
end

$ lowentc --run main hello.low
hello, entropy!
main() = 16

첫 줄 module hello . 는 모든 파일이 여는 모듈 선언이다. 둘째 줄의 rem 은 줄 주석이고, 이 책에서는 검증 스크립트에게 무엇을 할지 알려 주는 데 쓴다.

op 의 머리를 한 절씩 읽는다.

• proc main — 이름이 main 인 비순수 op. 출력은 바깥에 흔적을 남기므로 fn 이 될 수 없다.
• input out cap io . — io 권한을 out 이라는 이름으로 받는다. 표준출력에 쓰려면 이 권한이 있어야 한다.
• output u8 . — u8 을 돌려준다.
• effects io . — 입출력 효과를 낸다고 선언한다.

본문은 do 와 end 사이다. write_out out 1 "…" 는 권한 out 을 첫 인자로 받아 파일 기술자 1(표준출력)에 바이트를 쓰고, 쓴 바이트 수를 돌려준다. hello, entropy!\n 는 16 바이트이므로 16 이 나온다. 그것을 narrow u8 로 u8 에 맞게 좁혀 돌려준다. 좁히기는 값이 들어가지 않으면 실행 중에 멈추는 검사를 동반한다(4장).

실행 결과의 마지막 줄 main() = 16 은 VM 이 op 의 반환값을 보여 주는 줄이다.

2.3 두 가지로 돌린다#

--run 은 컴파일러 안의 가상 기계로 돌린 것이다. 같은 프로그램을 네이티브로 돌리려면 C 로 내보내고 C 컴파일러로 짓는다.

lowentc --emit-c hello.low > hello.c
cc -O2 -o hello hello.c -lm
./hello main

네이티브 실행 파일은 첫 인자로 돌릴 op 의 이름을 받는다. main 을 돌리면 화면에는 같은 한 줄이 찍히고, 반환값 16 은 프로세스의 종료 코드로 나온다(echo $? 로 본다). main 의 output 이 u8 인 까닭이다 — 종료 코드는 한 바이트다.

슬라이스 인자는 대괄호로 준다. 다음 op 은 바이트 슬라이스의 평균을 구한다.

module stats .
rem run: mean [3,4,8]

fn mean input xs slice u8 . output u64 .
  requires gt (len xs) 0 .
do
  var total u64 be 0 .
  for x xs do
    set total (add total (widen u64 x)) .
  end
  return div total (len xs) .
end

$ lowentc --run mean stats.low [3,4,8]
mean([3,4,8]) = 5
  arg0 (written) = [3,4,8]

requires gt (len xs) 0 . 는 계약이다. 호출자는 빈 슬라이스를 주지 않는다고 약속한다. 그 약속이 있으니 본문의 div total (len xs) 가 0 으로 나눌 걱정을 하지 않는다. 결과 아래의 arg0 (written) = [3,4,8] 은 VM 이 슬라이스 인자의 마지막 모습을 보여 주는 줄이다.

2.4 계약이 멈추는 모습#

계약을 어기면 어떻게 되는가. 다음 op 은 100 이하만 받는다.

module doubling .
rem run: twice 21
rem test

export fn twice input n u32 . output u32 .
  requires le n 100 .
do
  return mul n 2 .
end

test twice_works
do
  expect eq (twice 5) 10 .
  expect eq (twice 0) 0 .
end

$ lowentc --run twice twice.low 21
twice(21) = 42
$ lowentc --test twice.low
  [PASS] twice_works
== tests: 1 run, 1 passed, 0 FAILED ==

lowentc --run twice twice.low 200 처럼 약속을 어긴 값을 주면, VM 은 본문에 들어가기 전에 멈추고 E-VM-CONTRACT: requires violated at entry 를 낸다. 인자가 상수로 적힌 호출(twice 250)이면 실행할 필요도 없이 --check 가 E-CONTRACT-IMPOSSIBLE 로 거절한다. 계약은 주석이 아니다.

같은 파일의 test twice_works 블록은 시험이다. expect 가 단언이고, --test 가 모든 test 블록을 돌린다. 결과의 마지막 두 줄이 그 출력이다. --check 는 시험을 돌리지 않는다 — 검사가 통과했다고 시험이 통과한 것은 아니므로, 시험이 있는 파일을 --check 하면 컴파일러가 W-TEST-NOT-RUN 경고로 그 사실을 일러 준다.

2.5 거절당하기#

Lowent 를 배우는 시간의 상당 부분은 컴파일러에게 거절당하는 시간이다. 거절은 벌이 아니라 대화다. 진단마다 안정된 코드가 붙어 있고, 그 코드는 판이 바뀌어도 같은 뜻을 지킨다.

module twice_bad .
rem expect: E-EFFECT-CALC

fn shout input out cap io . output u64 .
do
  return write_out out 1 "hi\n" .
end

$ lowentc --check twice_bad.low
twice_bad.low:5:1 E-EFFECT-CALC: this fn is declared pure but performs `io` — make it a `proc` with `effects …`, or remove the effect

진단 한 줄은 파일:줄:칸 코드: 설명 의 꼴이다. 이 예에서 fn shout 은 순수하다고 선언했는데 본문이 write_out 으로 입출력을 한다. 컴파일러는 E-EFFECT-CALC 로 거절하고, 고치는 길 둘을 말한다 — proc 으로 바꾸고 effects 를 적거나, 효과를 없애거나.

--diag-json 을 붙이면 같은 진단이 JSON 한 줄로 나온다. 규칙 코드(rule), 위치(span), 고치는 방법의 이름(repair)이 칸으로 나뉘어 있어서, 편집기나 AI 가 설명 문장을 뜯지 않고도 무엇이 틀렸는지 안다.

{"rule":"E-EFFECT-CALC","sev":"error","phase":"effect", … ,"repair":"R-CALC-TO-PROC"}

2.6 모양을 고쳐 주는 --fmt#

op 머리의 절은 정해진 한 차례로 적는다. 입력이 출력보다 먼저다. 차례가 틀리면 거절된다.

module messy .
rem expect: E-CLAUSE-ORDER

fn area output u64 . input w u64 . input h u64 .
do
  return mul w h .
end

$ lowentc --check messy.low
messy.low:4:22 E-CLAUSE-ORDER: a data input comes after `output`. An op header has ONE order: `satisfies`/`lowdoc` · `vector`/`priority` · `comptime` inputs · capability/region inputs · `using` · data inputs · `output` · `effects` · `link`/`variadic` · `asm` · `access`/`inplace`/`invalidates`/`parallel`/`reduce` · `requires` · `ensures` · `errors` · `tests` (`--fmt` moves the non-input clauses for you; inputs are call positions, so reorder those and their call sites yourself)

진단의 긴 설명이 곧 차례표다. 전부는 3장에서 다루고, 지금은 한 가지만 기억한다: --fmt 는 입력이 아닌 절(출력·효과·계약 따위)을 제자리로 옮겨 준다. 입력끼리의 차례는 옮기지 않는다. 입력의 차례는 부르는 쪽 인자의 차례이기도 해서, 옮기면 모든 호출 자리가 함께 바뀌어야 하기 때문이다.

--fmt 가 찍는 정규형은 절마다 한 줄이고 괄호를 모두 드러낸다. 사람이 그 모양으로 쓸 필요는 없다. 정규형은 두 코드가 같은 뜻인지를 기계가 비교하는 기준이다.

2.7 인자와 권한#

프로그램 인자를 읽는 것도 권한이다. 다음 프로그램은 첫 인자를 받아 인사한다.

module greet .
rem (인자는 네이티브와 VM 의 번호가 달라 여기서는 검사만 한다)

proc main input out cap io . input a cap args . output u8 . effects io .
do
  let who option slice u8 be arg a 0 .
  guard is_some who . else return narrow u8 (write_out out 1 "no name\n") .
  let n u64 be write_out out 1 "hello, " .
  let m u64 be write_out out 1 (some_value who) .
  let k u64 be write_out out 1 "\n" .
  return 0 .
end

$ lowentc --check greet.low
== check: ok ==

input a cap args . 로 인자 권한을 받고, arg a 0 이 첫 인자를 읽는다. 인자가 없을 수도 있으니 결과는 option slice u8 이다. guard is_some who . else … 는 값이 없으면 그 자리에서 떠나고, 그 아래에서는 값이 있다고 믿어도 된다(11장). 권한 입력이 데이터 입력보다 앞에 오고, 권한 둘은 적은 차례대로 인자 자리를 차지한다.

effects io . 한 줄이 두 권한을 모두 덮는 것에 주목한다. args 는 효과 없이 읽을 수 있는 권한이다. 권한과 효과가 어떻게 짝지어지는지는 16장이 표로 정리한다.

2.8 흔한 실수#

첫 프로그램에서 가장 자주 만나는 거절과 멈춤이다. 진단 한 줄의 코드를 보고 여기로 돌아오면 된다.

module mistake_noend .
rem expect: E-BLOCK-UNCLOSED

proc main input out cap io . output u8 . effects io .
do
  let n u64 be write_out out 1 "hi\n" .
  return narrow u8 n .
rem ✘ 몸을 연 `do` 에 짝이 되는 `end` 가 없다

$ lowentc --check mistake_noend.low
5:1 E-BLOCK-UNCLOSED: missing 'end' for do-block

module mistake_nocap .
rem expect: E-EFFECT-NO-CAP

rem ✘ `io` 를 한다고 적었지만 권한(`cap io`)을 받지 않았다
proc main output u8 . effects io .
do
  let n u64 be write_out 1 "hi\n" .
  return narrow u8 n .
end

$ lowentc --check mistake_nocap.low
mistake_nocap.low:5:0 E-EFFECT-NO-CAP: this op declares the `io` effect but receives NO capability that authorizes it. `io` is a cap-effect (RFC-0007 §6.7): I/O is a RIGHT you are HANDED, not an ambient power — `input fs cap file_system .` (or another `cap …` input). An effect you declare but hold no capability for is a claim the signature cannot back

module mistake_exitcode .
rem trap: main

proc main input out cap io . output u8 . effects io .
do
  var n u64 be 0 .
  var i u64 be 0 .
  while lt i 8 . do
    set n (add n (write_out out 1 "32 bytes of text on every line.\n")) .
    set i (add i 1) .
  end
  rem ✘ 256 바이트를 썼다 --- 종료 코드는 한 바이트(0 … 255)라 들어가지 않는다
  return narrow u8 n .
end

$ lowentc --run main mistake_exitcode.low
32 bytes of text on every line.
32 bytes of text on every line.
32 bytes of text on every line.
32 bytes of text on every line.
32 bytes of text on every line.
32 bytes of text on every line.
32 bytes of text on every line.
32 bytes of text on every line.
== ir diagnostics (1) ==
0:0 E-VM-CAST: value does not fit the target width (use narrow_wrap / narrow_sat / narrow_try)

module mistake_opname .
rem trap: mian

proc main input out cap io . output u8 . effects io .
do
  let n u64 be write_out out 1 "hi\n" .
  return narrow u8 n .
end

$ lowentc --run mian mistake_opname.low
== ir diagnostics (1) ==
0:0 E-VM-UNDEF: no such op

2.9 이 장의 문법 한눈에#