5 op — fn 과 proc

5.1 두 갈래#

op(operation)은 이름과 계약을 가진 실행 단위다. 표면에서는 언제나 두 낱말 가운데 하나로 연다.

• fn — 순수한 op. 같은 입력이면 같은 결과를 내고 바깥에 흔적을 남기지 않는다.
• proc — 효과를 낼 수 있는 op. 무슨 효과를 내는지 effects 절에 적는다.

기본값은 없다. fn 인지 proc 인지는 이름 앞에 늘 적혀 있다. add 나 len 같은 내장 연산도 op 이다 — 언어가 미리 만들어 둔 op 이라서 내장 op 이라 부른다.

module kinds .
rem run: add3 1 2 3
rem run: running_total [4,5,6]
rem run: fact 10

fn add3 input a i32 . input b i32 . input c i32 . output i32 .
do
  return add (add a b) c .
end

rem 지역 가변 상태는 op 안에 갇혀 있으므로 fn 도 쓸 수 있다
fn running_total input xs slice u8 . output u64 .
do
  var total u64 be 0 .
  for x xs do
    set total (add total (widen u64 x)) .
  end
  return total .
end

fn fact input n u64 . output u64 .
  requires le n 20 .
do
  if le n 1 . do return 1 . end
  return mul n (fact (sub n 1)) .
end

$ lowentc --run add3 kinds.low 1 2 3
add3(1, 2, 3) = 6
$ lowentc --run running_total kinds.low [4,5,6]
running_total([4,5,6]) = 15
  arg0 (written) = [4,5,6]
$ lowentc --run fact kinds.low 10
fact(10) = 3628800

세 op 이 모두 fn 이다. add3 은 인자 셋을 받아 더하고, fact 는 자기 자신을 부르는 재귀다. fact 의 requires le n 20 . 은 21! 이 u64 를 넘기 때문에 붙인 계약이다. 이 계약이 없으면 fact 21 은 곱셈에서 멈춘다(4장). 계약이 있으면 진입에서 멈추고, 멈춘 자리가 부르는 쪽의 잘못임을 알린다.

5.2 순수함은 관측으로 정한다#

running_total 을 다시 보자. 본문에 var total 이 있고 set 으로 값을 바꾼다. 그런데도 fn 이다. Lowent 의 순수함은 관측적이기 때문이다. op 안에 갇힌 지역 변수의 변이는 바깥에서 볼 수 없으므로 순수로 친다. 기계어 수준에서 메모리에 쓰는 일이 일어나도, 호출자가 관측할 수 없으면 효과가 아니다.

반대로 호출자가 볼 수 있는 쓰기는 효과다. mut 매개변수를 통해 쓰는 fn 은 거절된다.

module mutparam .
rem expect: E-EFFECT-PURITY

fn zero_first input xs mut slice u64 . output u64 .
do
  set (index xs 0) 0 .
  return 0 .
end

$ lowentc --check mutparam.low
mutparam.low:4:0 E-EFFECT-PURITY: a `fn` WRITES through a `mut` parameter — that write is visible to the CALLER. A fn is an enforced purity contract (SPEC-003 §27): callers may memoise it, reorder it, or elide it. An op that changes caller-owned storage can do none of those. Declare it a `proc`. (Local mutation stays pure: storage confined to the op is not observable — a machine write is not an observable effect. RFC-0057)

진단이 설명하는 대로, fn 은 강제되는 순수 계약이다. 호출자는 fn 의 결과를 기억해 두거나(memoise), 부르는 차례를 바꾸거나, 결과를 쓰지 않으면 호출을 지워도 된다. 호출자의 저장소를 바꾸는 op 에는 그 어느 것도 할 수 없다. 그래서 proc 이어야 한다.

module mutproc .
rem run: zero_first [7,8,9]

proc zero_first input xs mut slice u8 . output u64 . effects state .
  requires gt (len xs) 0 .
do
  set (index xs 0) 0 .
  return len xs .
end

$ lowentc --run zero_first mutproc.low [7,8,9]
zero_first([0,8,9]) = 3
  arg0 (written) = [0,8,9]

effects state . 는 이 op 이 자기 바깥의 상태를 고친다는 선언이다. VM 이 보여 주는 arg0 (written) = [0,8,9] 가 그 흔적이다 — 호출자가 넘긴 슬라이스의 첫 원소가 바뀌었다.

5.3 fn 에는 effects 를 적지 않는다#

fn 의 효과는 이미 none 이다. 그래서 effects none . 을 덧붙이면 거절된다.

module redundant .
rem expect: E-EFFECT-REDUNDANT

fn square input a u64 . output u64 . effects none .
do
  return mul a a .
end

$ lowentc --check redundant.low
redundant.low:4:0 E-EFFECT-REDUNDANT: a `fn` is pure by contract, so `effects none .` says nothing that the `fn` did not already say — DROP the clause. One meaning must have one spelling (SPEC-002 §2.5). (Keep writing `effects` on `proc`: there it NARROWS, and omitting it means unrestricted.)

뜻이 틀려서가 아니라 한 뜻에 두 표기가 되기 때문이다. proc 에서는 사정이 다르다. proc 의 effects 절은 좁히는 일을 한다. 절이 없는 proc 은 좁히지 않은 것으로 읽힌다 — 입출력·할당·상태를 모두 할 수 있다고 본다. 그러니 proc 에는 절을 적는 편이 낫고, 적은 것보다 많은 일을 하면 거절되며, 적어 놓고 하지 않는 효과도 알려진다.

5.4 효과는 부르는 쪽으로 번진다#

op 을 부르면 그 op 의 효과가 부르는 쪽의 효과에 더해진다. 순수한 fn 이 io 를 내는 proc 을 부르면, 그 fn 은 더 이상 순수하지 않다.

module calls .
rem expect: E-EFFECT-CALC

proc say input out cap io . output u64 . effects io .
do
  return write_out out 1 "hi\n" .
end

fn helper input out cap io . output u64 .
do
  return say out .
end

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

helper 는 스스로 출력하지 않는다. 출력하는 것은 say 다. 그래도 거절된다. 이 규칙 덕분에 op 의 머리만 보고도 그 op 이 부르는 모든 op 의 효과를 알 수 있다. 효과를 숨긴 채 전달하는 길이 없다. 어떤 효과가 어떤 권한과 짝지어지는지는 15·16장에서 다룬다.

5.5 매개변수와 반환#

op 하나를 조각조각 뜯어 보면 이렇다. 처음 보는 사람이 가장 헷갈리는 것은 절마다 마침표로 끝난다는 점이다. 마침표는 문장의 끝처럼 “이 절은 여기까지” 를 알린다.

fn   add3   input a i32 .   input b i32 .   input c i32 .   output i32 .
│    │      └─ 매개변수 a 의 타입은 i32 ─┘                  └ 돌려주는 값의 타입
│    └─ 이름 (부를 때 쓴다)
└─ 갈래: fn(순수) 또는 proc(효과를 낼 수 있음)
do                          ← 몸이 여기서 시작한다
  return add (add a b) c .  ← 계산해서 돌려준다. 문장도 마침표로 끝난다
end                         ← 몸이 끝나고, 선언 전체도 끝난다(뒤에 점을 찍지 않는다)

부를 때는 이름 뒤에 인자를 공백으로 늘어놓는다. add3 1 2 3 이 한 번의 호출이고, 괄호는 호출 하나를 다른 호출의 인자로 넣을 때만 쓴다 — add3 (add3 1 2 3) 4 5. 괄호가 곧 “이 안이 값 하나” 라는 표시다. C 처럼 add3(1, 2, 3) 으로 쓰는 법은 없다. 쉼표는 이 언어에서 뜻이 없는 기호이고, 그래서 거절된다(아래 «흔한 실수»).

매개변수는 input <이름> <타입> . 한 절에 하나다. 여럿이면 절을 되풀이한다. 부르는 쪽은 절의 차례대로 인자를 준다. 돌려주는 값은 output <타입> . 하나이고, 본문에서 return <식> . 으로 돌려준다.

fn compare input a i32 . input b i32 . output i32 .
do
  return sub a b .
end

타입 앞에 붙는 낱말이 소유와 가변과 유무를 말한다. 자주 만나는 것은 다음과 같다.

반환값은 하나다. 여럿을 돌려주려면 struct 로 묶거나(10장), 호출자가 넘긴 mut 슬라이스에 쓴다.

5.6 neg 만 단항이다#

사칙 연산 add·sub·mul·div·mod 는 인자를 둘 받는다. 산술에서 인자를 하나 받는 것은 부호를 뒤집는 neg 뿐이다.

module negs .
rem run: flip 5
rem run: dist -3 4

fn flip input a i64 . output i64 .
do
  return neg a .
end

fn dist input a i64 . input b i64 . output i64 .
do
  return abs (sub a b) .
end

$ lowentc --run flip neg.low 5
flip(5) = -5
$ lowentc --run dist neg.low -3 4
dist(-3, 4) = 7

neg 는 부호 있는 타입의 일이다. 부호 없는 값에 쓰면 넘침이다. abs 는 절댓값이고, i64 의 가장 작은 값처럼 양수로 표현할 수 없는 값을 주면 멈춘다. expr 섬 안에도 단항 연산자는 없어서, 부호를 뒤집으려면 expr 0 - a 로 적거나 (neg a) 를 괄호로 부른다.

5.7 수식어#

op 머리 앞에 수식어를 붙일 수 있다.

• export — 다른 모듈에서 부를 수 있게 내보낸다. 네이티브로 낼 때는 C 에서 부를 수 있는 심볼이 된다. 붙이지 않은 op 은 그 모듈 안에서만 쓴다. 내보내는 것은 선택이지 부작용이 아니어야 하기 때문이다.
• extern — 구현이 바깥(C)에 있다. 본문 대신 link 절로 이름을 댄다(29장).
• unsafe — 언어가 검사할 수 없는 일을 한다. effects unsafe 와 짝이다.

unsafe extern proc c_area do
  input k cap c .
  input w i64 .
  input h i64 .
  output i64 .
  effects unsafe .
  link lw_c_area .
end

5.8 흔한 실수#

처음 op 을 쓸 때 누구나 한 번쯤 밟는 자리들이다. 모두 번역할 때 걸리므로, 진단 코드를 보고 이 절로 돌아오면 된다.

module mistake_ccall .
rem expect: E-VOCAB-REMOVED

fn add3 input a i32 . input b i32 . input c i32 . output i32 .
do
  return add (add a b) c .
end

fn use3 output i32 .
do
  rem ✘ C 처럼 괄호와 쉼표로 불렀다 --- Lowent 의 호출은 `이름 인자 인자 …` 다
  return add3(1, 2, 3) .
end

$ lowentc --check mistake_ccall.low
12:16 E-VOCAB-REMOVED: `,` (R3) was removed — RFC-0103, 2026-08-27. It opened the NEXT operand of the same form, but nothing used it that way: every `,` in the corpus was a LINE CONTINUATION, and newlines no longer close a form, so continuing a line needs nothing at all. A form is `head operand*` and ends at its closer `.` — just write the operands, on as many lines as you like.
12:19 E-VOCAB-REMOVED: `,` (R3) was removed — RFC-0103, 2026-08-27. It opened the NEXT operand of the same form, but nothing used it that way: every `,` in the corpus was a LINE CONTINUATION, and newlines no longer close a form, so continuing a line needs nothing at all. A form is `head operand*` and ends at its closer `.` — just write the operands, on as many lines as you like.

module mistake_arity .
rem expect: E-IR-ARITY

fn add3 input a i32 . input b i32 . input c i32 . output i32 .
do
  return add (add a b) c .
end

fn use3 output i32 .
do
  rem ✘ input 절이 셋인데 인자를 둘만 줬다
  return add3 1 2 .
end

$ lowentc --check mistake_arity.low
mistake_arity.low:12:0 E-IR-ARITY: `add3` takes 3 arguments but 2 are given here — an op call is `<name> <arg>…` with exactly as many arguments as its `input` clauses

module mistake_partial .
rem expect: E-RETURN-PARTIAL

fn sign input a i32 . output i32 .
do
  if gt a 0 . do
    return 1 .
  end
  rem ✘ a 가 0 이하일 때 돌려줄 값이 없다 --- 끝까지 내려오는 길이 있다
end

$ lowentc --check mistake_partial.low
mistake_partial.low:4:0 E-RETURN-PARTIAL: this op says it OUTPUTS a value, but some path through its body reaches the end without a `return`. Until now the tool quietly returned 0 there — a value that appears NOWHERE in your source (RFC-0019 G-TOTAL). Give every path a `return`, or say `output void` if it really produces nothing. An exhaustive `match` whose every arm returns counts as returning

module mistake_builtin .
rem expect: E-NAME-BUILTIN

rem ✘ `min` 은 이미 내장 op 의 이름이다 --- 이 선언은 영영 불리지 않는다
fn min input a u64 . input b u64 . output u64 .
do
  return add a b .
end

$ lowentc --check mistake_builtin.low
mistake_builtin.low:5:0 E-NAME-BUILTIN: this name is a BUILTIN — the resolver always picks the builtin, so your declaration can never be called: it exists and does not exist. The namespace is FLAT (no shadowing). Rename it

module discard .
rem run: caller

fn twice input a u64 . output u64 .
do
  return mul a 2 .
end

fn caller output u64 .
do
  rem 결과를 받지 않은 fn 호출 --- 순수하므로 아무 흔적도 남기지 않는다
  twice 5 .
  rem 결과를 쓰려면 이름에 묶는다
  let t u64 be twice 5 .
  return t .
end

$ lowentc --run caller discard.low
caller() = 10

5.9 이 장의 문법 한눈에#