로우엔트 — Lowent 프로그래밍 언어 표준 명세

6.2.1 타입의 갈래

1 타입은 다음 갈래로 나뉜다.

6.2.2 정수 타입

1 정수 타입의 이름은 부호와 폭으로 이루어진다. u 는 부호 없음, i 는 부호 있음이며, 뒤의 숫자가 비트 폭이다.

2 정수는 2 의 보수로 표현된다(§5.3).

3 usize 와 isize 는 주소를 셀 수 있을 만큼 넓은 정수다. 이 둘은 u64·i64 와 폭이 같더라도 다른 타입이며, 서로 자동으로 바뀌지 아니한다.

6.2.3 참거짓 타입

1 bool 은 참과 거짓 두 값만 갖는다. 표현은 1 바이트이며, 유효한 값은 0 과 1 뿐이다.

2 bool 과 정수는 서로 바뀌지 아니한다. 정수를 조건 자리에 쓸 수 없고, bool 을 숫자로 셈할 수 없다.

module ex_cond .

proc p input n u32 . output u8 . effects none .
do
  if n . do return 1 . end     rem `n` 은 bool 이 아니다
  return 0 .
end

6.2.4 부동소수점 타입

1 f32 와 f64 는 각각 IEEE 754 의 이진 32 비트·64 비트 형식이다.

2 부동소수점 연산은 피연산자의 폭에서 일어난다. f32 끼리의 연산은 f32 로 계산하며, 처리기가 몰래 더 넓은 정밀도로 계산하지 아니한다.

3 정수와 부동소수점은 서로 자동으로 바뀌지 아니한다. 바꾸려면 명시적으로 적어야 한다.

6.2.5 타입 사이의 변환

1 로우엔트에는 값을 잃는 암묵적 변환이 없다. 좁아지는 자리는 언제나 소스에 적혀 있다.

2 값을 잃지 않는 변환을 넓히기 (widening) 라 한다. 넓히기는 값을 바꾸지 않으므로 처리기가 자동으로 할 수 있다 — u8 값을 u32 를 받는 자리에 그대로 넘길 수 있다.

2a 다만 넓히기를 소스에 적을 수도 있다. widen u64 x 는 x 를 u64 로 넓힌다. 결과가 같더라도, 폭이 바뀌는 자리를 눈에 보이게 하고 싶을 때 쓴다.

3 값을 잃을 수 있는 변환을 좁히기 (narrowing) 라 하며 narrow 로 적는다. 좁히기는 값이 목표 타입에 들어가지 않으면 트랩한다. 조용히 잘리지 아니한다.

4 넓히기가 허용되는 관계는 다음과 같다. 여기 없는 조합은 넓히기가 아니며, 적으면 번역이 거부된다(E-WIDEN-KIND · E-WIDEN-SIGN · E-WIDEN-NARROW).

let small u8 be 200 .
let wide u64 be widen u64 small .
let back u8 be narrow u8 wide .

6.2.6 줄 — 배열과 슬라이스

1 array n t 는 타입 t 의 값이 정확히 n 개 놓인 줄이다. 길이는 타입의 일부이며 번역 시점에 정해진다.

1a 길이 n 은 정수 리터럴로, 타입보다 먼저 적는다. 반대로 적거나(array t n) 리터럴이 아니면 거부된다(E-TYPE-ARRAY).

1b op 의 입력 input x array n t . 는 길이가 정확히 n 인 slice t 를 받는다는 뜻이며, 그 길이는 requires eq (len x) n . 과 같이 진입에서 검사된다.

2 slice t 는 타입 t 의 값이 연속으로 놓인 구간을 가리키는 것이며, 시작과 길이를 함께 갖는다.

3 슬라이스의 길이는 len 으로 읽는다. len s 는 s 의 원소 개수다.

4 index s i 는 s 의 i 번째 원소다. 첫 원소의 번호는 0 이다.

5 i 가 len s 보다 작지 않으면 트랩한다. 처리기가 그 조건이 언제나 참임을 증명하면 그 검사는 사라진다(§6.4.6).

module ex_slice .

rem 슬라이스는 시작과 길이를 함께 갖는다.
export fn head input data slice u8 . . output u8 .
  requires ge (len data) 1 .
do
  return index data 0 .
end

module ex_array_order .

export fn last input xs array u64 4 . output u64 .
do
  return index xs 3 .
end

6.2.7 묶음 — struct 와 enum

1 struct 는 이름 붙은 칸의 모음이다. 각 칸은 자기 타입을 갖는다.

2 enum 은 여럿 중 하나다. 각 갈래는 이름을 가지며, 값을 함께 지닐 수 있다.

2a 갈래는 하나마다 . 으로 닫는다. 개행은 닫개가 아니므로, 점 없이 줄마다 적은 갈래는 한 갈래로 이어지며 거부된다(E-ENUM-DOT). 갈래가 지니는 값은 <칸 이름> <타입> 짝으로 적는다 — 짝이 맞지 않으면 거부된다(E-ENUM-FIELD).

3 struct 는 자기 자신을 칸으로 가질 수 없다. 직접이든 다른 타입을 거쳐서든 순환하면 번역이 거부된다. (E-STRUCT-CYCLE). 크기가 정해지지 아니하기 때문이다.

3a 참조를 거쳐 자기를 가리키면 크기는 정해진다. 다만 그 참조가 누가 관리하는지 알 수 없는 것이면 거부된다(E-STRUCT-REF-UNMANAGED) — 크기가 있다고 수명이 선 것은 아니다.

module ex_shape .

struct point do
  x u32 .
  y u32 .
end

enum color do
  red .
  green .
end

4 struct 값은 make 로 만든다. 만들 때 모든 칸을 채워야 한다.

5 칸을 읽을 때는 field <값> <칸 이름> 을 쓴다. 값 뒤에 점과 칸 이름을 붙이는 모양은 없다 (E-FIELD-GLUED) — 점은 모듈 한정·갈래 이름에 이미 쓰인다.

module ex_make .

struct point do
  x u32 .
  y u32 .
end

export fn origin output point .
do
  return make point do x 0 . y 0 . end .
end

export fn get_x input p point . output u32 .
do
  return (field p x) .
end

module ex_enum_dot .

enum color do
  red
  green
end

6.2.8 답을 담는 타입 — result 와 option

1 result t e 는 성공한 값(t) 또는 오류(e) 중 하나를 담는다.

2 option t 는 값이 있거나 없음을 담는다.

3 이 두 타입의 값은 꺼내기 전에 어느 쪽인지 확인해야 한다.

3a 꺼내는 연산은 부분 연산이다 — 확인하지 않고 꺼내는 것 자체는 번역이 거부하지 아니하며, 실행 중에 없는 쪽을 꺼내면 트랩한다. 곧 확인은 번역이 대신해 주는 것이 아니라 저자가 하는 것이다.

module ex_result .

enum err do
  too_small .
end

rem 2 보다 작으면 반으로 나눌 수 없다고 알린다.
export fn half input n u32 . output result u32 err . .
  errors too_small lt n 2 .
do
  guard ge n 2 . else return error too_small .
  return ok (div n 2) .
end

4 만드는 쪽은 ok(성공) error(오류) some(값이 있음) none(값이 없음) 으로 값을 싼다.

5 받는 쪽은 먼저 어느 쪽인지 묻는다 — is_error(오류인가) is_some(값이 있는가). 그 다음 꺼낸다 — ok_value(성공 값) error_value(오류) some_value(있는 값).

6 value_or 는 값이 있으면 그 값을, 없으면 대신 줄 값을 낸다. 묻고 꺼내는 두 걸음을 한 걸음으로 줄인다.

7 try 는 result 를 받아 성공하면 값을 꺼내고 실패하면 그 오류를 그대로 위로 넘긴다(§6.5.7).

8 result 를 받고 아무도 그것을 보지 아니하면 처리기는 알린다 (W-RESULT-DISCARD). 실패를 값으로 돌려준다는 설계는 받는 쪽이 그 값을 볼 때만 지켜진다. 보지 않는 모양은 둘이다 — op 을 문장으로 불러 값을 이름조차 없이 버리는 것, 그리고 이름에 담아 두고 한 번도 읽지 아니하는 것.

8a 실패를 일부러 넘기는 자리는 drop <이름> . 으로 적는다. 그러면 알리지 아니한다. 실패로 할 일이 정말 없는 자리가 있다 — 오류 경로에서 자원을 닫고 나가는 자리가 그렇다. drop 은 이미 «나는 이것을 여기서 끝낸다» 를 뜻하므로, 그 자리에 새 낱말을 두지 아니한다.

module ex_partial .

fn mk input k u8 . output option u8 . .
do
  guard lt k 3 . else return none .
  return some (mul k 10) .
end

rem 확인 없이 바로 꺼낸다 — 번역은 통과한다.
fn raw input k u8 . output u8 .
do
  return some_value (mk k) .
end

raw(2) = 20 · raw(7) → E-VM-NONE (트랩)

module ex_option .

rem 만드는 쪽 — 값이 있으면 some, 없으면 none.
fn lookup input k u8 . output option u8 . .
do
  guard lt k 3 . else return none .
  return some (mul k 10) .
end

rem 받는 쪽 ① — 묻고 꺼낸다.
fn use_ask input k u8 . output u8 .
do
  let r option u8 . be lookup k .
  guard is_some r . else return 255 .
  return some_value r .
end

rem 받는 쪽 ② — 없으면 대신 쓸 값을 준다.
fn use_or input k u8 . output u8 .
do
  return value_or (lookup k) 99 .
end

use_ask(2) = 20 · use_ask(7) = 255 · use_or(2) = 20 · use_or(7) = 99

module ex_result_use .

enum io_error do
  too_big .
end

rem 만드는 쪽 — 언제 실패하는지 계약으로 적는다.
fn halve input a u8 . output result u8 io_error .
  errors too_big gt a 200 .
do
  guard le a 200 . else return error too_big .
  return ok (div a 2) .
end

rem 받는 쪽 ① — 묻고 꺼낸다.
fn use_ask input a u8 . output u8 .
do
  let r result u8 io_error . . be halve a .
  guard not (is_error r) . else return 0 .
  return ok_value r .
end

rem 받는 쪽 ② — try 는 실패를 그대로 위로 넘긴다.
fn use_try input a u8 . output result u8 io_error .
  errors too_big gt a 200 .
do
  let v u8 be try halve a .
  return ok (add v 1) .
end

use_ask(100) = 50 · use_ask(250) = 0 · use_try(100) = ok 51

6.2.9 이름 붙인 타입

1 type 은 기존 타입에 다른 이름을 준다. 두 이름은 같은 타입이며 서로 바꿔 쓸 수 있다.

2 newtype 은 기존 타입과 같은 표현을 갖되 다른 타입을 만든다. 서로 바꿔 쓸 수 없다.

2a 모양은 type <이름> <타입> . 과 newtype <이름> <타입> . 이다. 이름과 타입 사이에 be 를 끼우지 아니한다 — be 는 let·var 가 값을 묶는 낱말이고, 여기서 묶는 것은 타입이다. be 를 끼운 꼴은 거부된다(E-TYPE-DECL).

module ex_type_be .

type pct be u8 .

fn f output pct . do
  return 1 .
end

3 newtype 이 저장소를 가르는 이름(상표 (brand))으로 쓰일 때, 한 상표는 저장소 하나를 가리킨다. 같은 상표로 저장소를 두 번 여는 것은 거부된다 (E-BRAND-REUSED) — 그러면 한 이름이 둘을 가리키게 되고, 서로 다른 저장소에서 온 손잡이가 같은 타입으로 보인다. 그것은 상표가 막으려던 바로 그 혼동이다. 갈라야 한다면 newtype 을 하나 더 선언한다.

6.2.10 값의 안을 읽는다 — field

1 field 는 값의 안에 있는 것을 읽는 폼이다. 모양은 field <값> <마디> … 이며, 마디는 하나 이상이다. 마디가 여럿이면 왼쪽에서 오른쪽으로 한 칸씩 내려간다 — field o inner deep 은 o 의 inner, 그 안의 deep 을 뜻한다.

2 마디는 두 가지 중 하나다. 이름이면 struct 의 필드이고, 정수이면 줄(배열·슬라이스)의 자리다. 둘은 섞일 수 있다.

3 field 는 자리 (place) 이기도 하다 — set 의 왼쪽에 올 수 있다. 읽는 자리와 쓰는 자리가 같은 철자를 갖는다.

4 선언에 없는 필드를 적으면 처리기는 프로그램을 거절한다. 줄의 자리는 §6.2.6 의 경계 규칙을 따른다.

module ex_field .

struct inner do
  a u64 .
end

struct outer do
  i inner .
end

export fn read_deep input o outer . output u64 .
do
  return (field o i a) .
end

export proc bump_deep input o mut outer . .
  effects state .
do
  set (field o i a) 1 .
end

6.2.11 레인을 가진 값 — `vec`

1 vec <원소 타입> <레인 수> 는 같은 타입의 값 여럿을 한 값으로 든다. 레인 수는 번역 시점에 정해진 값이어야 한다(§6.8).

2 레인 수가 다른 두 vec 은 서로 다른 타입이며 섞이지 아니한다.

3 vec 에 대한 산술은 레인마다 따로 일어난다. 레인 사이에 값이 넘나들지 아니한다.

6.2.12 비트로 이루어진 집합 — `bitset`

1 bitset <비트 수> 는 0 부터 그 수 미만까지의 값이 들어 있는지 없는지를 담는다. 비트 수는 번역 시점에 정해진 값이어야 한다.

2 범위 밖의 값을 넣거나 묻는 것은 적합하지 아니하다.

3 bitset 은 집합이지 워드의 비트가 아니다. 워드의 비트를 다루는 것은 비트 연산이며 (§6.3), 둘은 서로 다른 것이다.

6.2.13 바이트 위에 얹는 눈 — 뷰

1 바이트 슬라이스를 복사 없이 다른 타입의 배열처럼 읽을 수 있다. 이것을 뷰(view)라 한다.

2 뷰를 얻을 때 정렬과 길이의 계약이 확인된다. 계약이 깨지면 프로그램이 멈춘다.

3 뷰는 바이트를 복사하지 아니한다. 뷰를 통해 쓰면 원래 바이트가 바뀐다.

4 뷰의 반대는 encode 다. encode <짜임> <값> 은 그 값을 짜임이 정한 배치대로 바이트에 적는다. 얹어 읽는 것이 view 라면, 적어 내리는 것이 encode 다.

6.2.14 값의 범위를 좁힌 매개변수 — `range`

1 매개변수의 타입 자리에 range <아래> <위> 를 적으면, 그 매개변수는 두 끝을 포함한 그 사이의 값만 받는다.

2 부르는 쪽이 그 범위 안임을 증명하지 못하면 번역이 거부된다. 프로그램 바깥에서 들어온 값(진입점의 인자 따위)은 증명할 부르는 쪽이 없으므로, 경계에서 확인되며 범위를 벗어나면 프로그램이 멈춘다.

2a 부르는 쪽의 타입이 그 범위보다 넓으면 그것만으로 거부된다(E-TYPE-WIDTH). 폭이 같아 그 검사에 걸리지 않는 값은 op 의 진입에서 범위를 확인하며, 벗어나면 멈춘다 (E-VM-CONTRACT) — requires ge <이름> <아래> . 와 requires le <이름> <위> . 를 적은 것과 같은 검사다.

3 선언한 범위는 §6.4 의 계약과 같은 자격으로 쓰인다 — 검사기가 그것을 사실로 삼아 뒤따르는 검사를 지울 수 있다.

module ex_range_wide .

fn scale input a range 0 100 . output u8 .
do
  return narrow u8 a .
end

fn call_scale input x u64 . output u8 .
do
  return scale x .    rem `u64` 는 0 … 100 보다 넓다 — 범위 안임을 보이지 않았다
end

6.2.15 바이트 배치를 못 박는다 — `layout` 과 `align`

1 구조체의 선언 안에 배치를 적을 수 있다. 적지 아니하면 배치는 처리기가 정한다.

2 layout packed . 은 필드 사이에 채움(padding)을 두지 아니한다 — 필드가 선언 차례로 맞붙는다.

2a 배치의 낱말은 닫힌 둘이다 — packed 와 native. 그 밖은 거부된다 (E-TYPE-LAYOUT).

3 align <n> . 은 그 구조체가 시작하는 자리의 정렬을 못 박는다. n 은 2 의 거듭제곱이어야 한다. 정렬은 2 의 거듭제곱이어야 한다(E-TYPE-ALIGN) — 그 밖의 수는 어떤 기계도 지킬 수 없다.

표지 (marker)

필드 뒤에 붙여 그 필드가 어떻게 놓이고 어떻게 닿을 수 있는지를 정하는 낱말. 타입이 아니므로 값의 크기를 바꾸지 아니하며, 바이트 차례와 닿는 법만 정한다.

4 필드 뒤에는 표지 (marker) 를 붙일 수 있다. 표지는 다음 다섯이 전부이며, 그 밖의 낱말을 적으면 번역이 거부된다(E-FIELD-MARK).

4a 바이트 차례를 적지 아니하면 그 기계의 차례를 따른다(§5.6).

4b 닿는 법은 장치 레지스터를 비추는 구조체(§7.6)에서만 강제된다. 어긴 것은 실행할 때가 아니라 번역할 때 거부된다(E-MMIO-PERM).

module ex_layout .

type bytes slice u8 .

struct wire_header do
  layout packed .
  magic u32 big .
  length u16 big .
  kind u8 .
end

fn hdr_kind input b bytes . output u64 . do
  var v view wire_header . be view wire_header b .
  return widen u64 (field v kind) .
end

6.2.16 갈래를 넘는 변환 — `cast`

1 widen(§6.2.5)은 값이 변하지 않는 자리에만 쓴다. 값이 변할 수 있는 변환은 cast <타입> <값> 으로 적는다 — 부호를 바꾸거나, 갈래를 넘거나, 좁히는 자리다.

2 cast 는 값이 목표 타입에 들어가지 아니하면 트랩한다. 조용히 잘리지 아니한다. 곧 cast 는 «아무 일이나 해도 된다» 는 표시가 아니라 “값이 변할 수 있는 자리임을 내가 안다” 는 표시다.

3 부동소수를 정수로 바꾸면 0 쪽으로 버린다 — 7.9 는 7 이 되고 -2.9 는 -2 가 된다. 버려지는 것은 소수부뿐이며, 정수부가 목표 타입에 안 들어가면 (2) 대로 트랩한다.

4 bool 은 수치가 아니므로 cast 의 대상도 원천도 될 수 없다(E-TYPE-KIND). 참거짓과 수를 오가려면 if 로 적는다 — 어느 쪽이 1 인지는 프로그램이 정할 일이지 타입이 정할 일이 아니다.

6.2.17 글자를 담는 것 — 문자열은 타입이 아니다

1 이 언어에는 문자열 타입이 없다. 글자를 담는 것은 바이트의 조각(slice u8)이며, 그것이 전부다.

2 그러므로 길이가 진실이다. 문자열의 끝을 알려 주는 표식(널 바이트)은 값의 일부가 아니며, 길이를 세기 위해 바이트를 훑는 일은 일어나지 아니한다.

3 씨와 만나는 자리에서만 널로 끝나는 꼴이 필요하다(§6.9.2). 그것은 경계에서 짓는 모양이지 이 언어가 지닌 타입이 아니다.

4 글자의 다룸 — 자르기·찾기·이어 붙이기·유니코드 검사 — 은 라이브러리의 일이다 (§9.5). 처리기는 조각과 바이트만 안다.

6.2.18 뜻이 없는 타입 이름

1 어떤 이름은 받아들여지되 뜻이 없다. 그런 이름을 시그니처에 적으면 처리기는 경고한다(W-NOT-YET).

2 뜻이 없다는 것은 낮추는 쪽이 그 이름을 읽지 못한다는 말이다. 그러면 그 시그니처를 가진 op 은 통째로 해석기로 떨어진다 — 답은 맞고, 속도만 사라진다.

3 이름에 뜻을 주는 길은 둘이다. 바탕이 되는 타입을 직접 적거나, 그 이름을 선언하는 것이다(type str slice u8 .). 선언한 뒤에는 뜻이 있으므로 경고하지 아니한다.

module ex_name_only .

rem `str` 은 내장이 아니다 — 뜻을 주지 않으면 W-NOT-YET 을 받는다.
type str slice u8 .

fn f input s str . output u8 . do return 1 . end

f() = 1

6.2.19 값을 지닌 갈래 — 짓기와 해체

1 enum 의 갈래는 값을 지닐 수 있다. 갈래를 적을 때 지닐 것의 이름과 타입을 함께 적는다.

2 그런 값을 짓는 모양은 <열거>.<갈래> 이며, 갈래가 지니기로 한 것을 모두 준다. 모자라면 거부된다(E-ENUM-ARITY) — 조용히 반만 지은 값을 만들지 아니한다.

3 값을 지닌 열거를 다루는 길은 둘이다.

4 없는 갈래를 부르면 거부되고(E-ENUM-NOVARIANT), 그 갈래가 지니지 않는 이름을 읽으려 하면 거부된다(E-ENUM-NOFIELD). 둘 다 번역할 때 판정된다 — 갈래와 이름은 소스에 적혀 있으므로 실행을 기다릴 까닭이 없다.

5 갈래가 여럿인 열거에서 get 은 먼저 그 갈래임이 좁혀진 뒤에만 쓸 수 있다 (E-ENUM-UNCHECKED). 좁히는 것은 isa 이며, 보통 guard isa <값> <갈래> . else … 로 적는다.

5a 이미 다른 갈래로 좁혀진 자리에서 get 을 쓰는 것도 거부된다 (E-ENUM-VARIANT) — 그 자리에서는 다른 갈래임이 이미 증명되었으므로, 그 get 은 틀린 것을 읽는다.

5b 갈래가 지니는 것의 타입은 오늘 한 낱말이어야 한다(E-ENUM-PAYLOAD).

6 열거가 자기 자신을 값으로 지니면 크기가 정해지지 아니하므로 거부된다 (E-ENUM-INFINITE). 되풀이되는 구조는 사이에 무언가를 두어 짓는다.

6.2.20 흩어진 조각을 하나로 보기 — `segments`

1 이어져 있지 않은 여러 조각을 하나의 눈으로 볼 수 있다. 뒤에 놓인 바이트와, 그 안에서 어디부터 얼마인지를 적은 서술자 둘로 이루어진다.

2 서술자는 「어디부터」와 「얼마」의 짝을 담은 조각이다. 그러므로 이 셋은 새 타입도 새 기계 명령도 늘리지 아니한다 — 묶음 짓기와 칸 읽기와 잘라내기로 낮아진다.

6.2.21 미리 끌어오기 — `prefetch`

1 prefetch <조각> <번호> 는 그 자리의 바이트를 곧 쓸 것이라고 기계에 알린다.

2 이것은 힌트일 뿐이다. 값을 남기지 아니하고, 프로그램의 뜻을 바꾸지 아니하며, 기계가 무시해도 답은 같다.

6.2.22 타입이 맞는다는 것

1 값을 두는 모든 자리에서 값의 타입은 그 자리가 적은 타입과 같아야 한다.

2 묶음과 열거는 struct <이름> do … end · enum <이름> do … end 로 선언한다. 다른 모양으로 선언하려 하면 거부된다(E-TYPE-DECL).

3 칸의 배치가 같아도 이름이 다르면 다른 묶음이다(E-TYPE-STRUCT, §8.9).

6.2.23 칸을 적는 꼴

1 묶음의 칸은 이름 다음에 타입이다(x u64 .). 그 꼴이 아니면 거부된다 (E-FIELD-FORM).

2 칸을 읽을 때는 field <값> <이름> … 으로 적는다. 점을 붙여 읽는 옛 철자는 이 언어에 없다(E-FIELD-GLUED).

3 vec 과 가림막은 값 그 자체이며, 가리키거나 빌리는 표지를 붙일 수 없다 (E-VEC-QUAL). 그 레인들은 낱말 안의 자리이지 메모리의 자리가 아니다.

module ex_field_form .

struct p do
  x .              rem 타입이 없다
end

fn f output u8 . do return 1 . end

6.2.24 임의 폭 정수 — `bits`

1 type <이름> bits <수> . 은 그 수만큼의 비트를 가진 정수 타입을 만든다. 폭은 1 부터 64 까지다.

2 폭은 2 의 거듭제곱일 필요가 없다 — bits 3 도 bits 10 도 선다.

6.3.1 전위 표기가 기본이다

1 식은 전위 표기 (prefix notation) 로 적는다 — 연산의 이름이 먼저 오고 인자가 뒤에 온다.

2 전위 표기에는 우선순위 규칙이 없다. 어떤 것이 먼저 계산되는지는 괄호와 순서가 전부 말해 준다.

2a 괄호를 생략하고 부름을 겹쳐 적을 수 있다 — add 1 mul a b 는 add 1 (mul 2 3) 과 같은 방식으로 묶인다. 묶는 규칙은 인자 수다: 낱말을 왼쪽에서 오른쪽으로 읽다가 연산 이름을 만나면 그 연산이 받는 수만큼 뒤의 것을 가져간다. 인자 수는 낱말마다 정해져 있으므로(부록 D) 이 묶기는 하나로 정해진다.

2b 그러나 읽는 사람은 인자 수를 외워야 한다 — (2) 가 없애려던 바로 그 외움이다. 그러므로 괄호 생략은 적합하되, 이 문서의 예제와 표준 라이브러리는 괄호를 적는다.

let a u32 be add 1 2 .
let b u32 be add 1 (mul 2 3) .
let c bool be lt a b .

6.3.2 중위 표기 — `expr` 섬

1 산술이 길어지면 읽기 어려우므로, expr 로 시작하는 자리에서는 중위 표기 (infix notation) 를 쓸 수 있다. 이 자리를 섬 (island) 이라 한다.

2 섬 안의 표기는 전위와 완전히 같은 뜻으로 바뀐다. 섬은 표기의 투영일 뿐이며 실행 비용이 없다.

3 우선순위는 오직 섬 안에만 있다. 다음 표가 그 전부다.

4 and 가 or 보다 강하게 묶는다. 곧 expr a or b and c 는 or a (and b c) 와 같다.

5 비교는 이어 쓸 수 없다. expr a lt b lt c 는 거부된다.

6 위 표가 섬의 전부다. 이 집합은 닫혀 있으며 늘어나지 않는다. 표에 없는 연산은 — 비트 연산(§6.3.5) · 나머지 mod · 최소 min 최대 max 를 비롯해 — 섬 안에서도 전위로 적는다.

7 단항 연산도 섬에 없다. 부호를 뒤집으려면 expr 0 - a 로 적거나 전위 폼을 괄호로 묶는다(expr (not b) or c).

module ex_infix .

export fn score input a u32 . input b u32 . output u32 .
  requires le a 1000 .
  requires le b 1000 .
do
  return expr a + b * 2 .
end

module ex_chain .

proc p input a u32 . input b u32 . input c u32 . output bool . effects none .
do
  return expr a lt b lt c .     rem 두 비교를 이어 쓸 수 없다
end

6.3.3 내장 연산

1 내장 연산 (builtin op) 은 언어가 뜻을 정해 둔 연산이다. 이름의 목록은 고정되어 있고, 전체는 부록 D 에 있다.

1a 내장 연산의 이름이 모두 같은 규칙을 갖지는 아니한다. 대부분은 지역 이름으로 쓸 수 없으나(§6.1.3), 일부는 문맥 안에서만 연산이므로 그 밖에서는 저자의 이름이 될 수 있다. 어느 쪽인지는 부록 D 가 적는다.

1b 아래에 드는 것은 기본이 되는 것을 갈래별로 보인 것이지 전부가 아니다. 전체 목록과 각 연산의 뜻은 부록 D 에 있다.

1c 내장 연산 가운데 계산 잎은 머리말 call_builtin 뒤에서만 선다: call_builtin <이름> <피연산자>*. 그 이름은 닫힌 집합이며 그 자리에서만 뜻이 있다 — 전역 이름이 아니므로 저자가 같은 철자를 제 이름으로 쓸 수 있다(§6.1.3 의 가림 금지가 여기에는 미치지 아니한다). 어느 이름이 그러한지는 부록 D 가 적는다.

1d 계산 잎을 call_builtin 없이 머리에 놓는 것은 적합하지 아니하다(E-BUILTIN-BARE). call_builtin 뒤에 그 닫힌 집합 밖의 낱말을 놓는 것도 적합하지 아니하다 (E-BUILTIN-NAME) — 그 자리는 저자의 이름으로 조용히 넘어가지 아니한다.

module ex_bare .

proc p input s slice u8 . input o mut slice u8 . output u64 . effects none .
do
  return sha256 s o .
end

module ex_call .

proc p input s slice u8 . input o mut slice u8 . output u64 . effects none .
do
  return call_builtin sha256 s o .
end

2 산술 연산은 add sub mul div mod 이다. 나머지를 내는 연산의 철자는 mod 이며, rem 은 주석을 여는 낱말이다(§6.1.2) — 같은 철자를 두 뜻에 쓰지 아니한다.

3 비교 연산은 eq ne lt le gt ge 이며 결과는 bool 이다.

4 논리 연산은 and or not 이며 피연산자와 결과가 모두 bool 이다. and 와 or 는 단락 평가 (short-circuit) 한다 — 앞쪽만으로 결과가 정해지면 뒤쪽을 계산하지 않는다.

5 슬라이스 연산은 len index 이다(§6.2.6).

6 변환 연산은 widen narrow 이다(§6.2.5).

7 비트 연산은 §6.3.5 에 있다.

6.3.4 산술의 규칙

1 이항 산술의 두 피연산자는 넓히기 관계로 비교 가능해야 한다(§6.2.5). 비교할 수 없으면 번역이 거부된다. 폭이 다르기만 하면 넓은 쪽으로 맞추어 계산한다.

1a 부호가 섞여도, 값을 지키는 넓히기가 있으면 계산할 수 있다. 부호 없는 쪽이 결과 타입 안에 값을 잃지 않고 들어가면 된다 — u8 과 i16 은 섞을 수 있다.

1b 그런 넓히기가 없으면 번역이 거부된다. u32 와 i32 는 폭이 같아 부호 없는 쪽이 부호 있는 쪽에 들어가지 못하므로 섞을 수 없다.

2 결과의 타입은 두 피연산자 중 넓은 쪽이다. 처리기는 두 피연산자 어느 것도 아닌 제3 의 타입을 만들어 내지 아니한다.

3 산술은 선언된 폭에서 일어난다. 결과가 그 폭에 들어가지 않으면 트랩한다.

4 정수를 0 으로 나누면 트랩한다. 부동소수점을 0 으로 나누면 IEEE 754 가 정한 대로 무한이 된다.

5 div 와 mod 는 선언된 부호로 해석한다.

module ex_mixsign .

rem `u8` 은 `i16` 안에 값을 잃지 않고 들어간다.
fn ok_widen input a u8 . input b i16 . output i16 . do return add a b . end

rem 더 넓은 자리를 결과로 골라도 된다.
fn ok_wider input a u8 . input b i16 . output i32 . do return add a b . end

ok_widen(200, -100) = 100 · ok_wider(200, -100) = 100

module ex_sign .

proc p input a i32 . input b u32 . output i32 . effects none .
do
  return add a b .     rem `u32` 는 `i32` 안에 안 들어간다 — 폭이 같다
end

6.3.5 비트 연산 (Bitwise operations)

1 비트 연산은 값을 비트의 나열로 보고 다룬다. 피연산자와 결과는 정수이며, 부호 있는 정수도 다룰 수 있다.

1a 오른쪽 옮기기 shr 는 부호에 따라 뜻이 다르다. 부호 없는 정수에서는 빈자리에 0 이 들어오고(논리 이동), 부호 있는 정수에서는 부호 비트가 들어온다(산술 이동). 그래서 음수를 오른쪽으로 옮겨도 음수로 남는다.

2 비트별 논리 연산은 bit_and bit_or bit_xor bit_not 이다. 앞의 셋은 두 값을 받고 bit_not 은 하나를 받는다.

3 옮기기는 shl(왼쪽) 과 shr(오른쪽) 이다. 돌리기는 rotl 과 rotr 이며, 밀려난 비트가 반대쪽으로 돌아 들어온다.

4 옮기는 칸 수는 타입의 폭보다 작아야 한다. 그렇지 않으면 트랩한다.

5 wrap_shl 과 wrap_shr 은 옮기는 칸 수를 폭 안으로 감싸서 쓴다. 폭이 8 인 타입에서 9 칸을 말하면 1 칸으로 읽는다.

6 세는 연산은 count_ones(1 인 비트의 수) leading_zeros(맨 앞부터 0 이 이어지는 수) trailing_zeros(맨 뒤부터 0 이 이어지는 수) 이다.

7 byte_swap 은 바이트의 차례를 뒤집는다. 엔디안이 다른 곳과 값을 주고받을 때 쓴다.

module ex_bitlogic .

rem 12 = 0000_1100 · 10 = 0000_1010
fn mask input a u8 . input b u8 . output u8 . do return bit_and a b . end
fn both input a u8 . input b u8 . output u8 . do return bit_or  a b . end
fn diff input a u8 . input b u8 . output u8 . do return bit_xor a b . end
fn flip input a u8 . output u8 . do return bit_not a . end

mask(12,10) = 8 · both(12,10) = 14 · diff(12,10) = 6 · flip(12) = 243

module ex_bitshift .

fn up   input a u8 . input n u8 . output u8 . do return shl  a n . end
fn down input a u8 . input n u8 . output u8 . do return shr  a n . end
fn spin input a u8 . input n u8 . output u8 . do return rotl a n . end
fn back input a u8 . input n u8 . output u8 . do return rotr a n . end

up(3,2) = 12 · down(12,2) = 3 · spin(129,1) = 3 · back(3,1) = 129

module ex_signed_shift .

rem 부호 있는 정수 — 빈자리에 부호 비트가 들어온다(산술 이동).
fn s_shr input a i32 . input n i32 . output i32 . do return shr a n . end

rem 부호 없는 정수 — 빈자리에 0 이 들어온다(논리 이동).
fn u_shr input a u32 . input n u32 . output u32 . do return shr a n . end

rem 비트별 논리 연산도 부호 있는 정수를 다룬다.
fn s_and input a i32 . input b i32 . output i32 . do return bit_and a b . end
fn s_not input a i32 . output i32 . do return bit_not a . end

s_shr(-8, 1) = -4 · u_shr(4294967288, 1) = 2147483644 · s_and(-8, 12) = 8 · s_not(0) = -1

module ex_bitcount .

fn ones input a u8 . output u8 . do return count_ones a . end
fn lead input a u8 . output u8 . do return leading_zeros a . end
fn tail input a u8 . output u8 . do return trailing_zeros a . end
fn endian input a u32 . output u32 . do return byte_swap a . end

ones(7) = 3 · lead(1) = 7 · tail(8) = 3 · endian(1) = 16777216

2 비트 연산은 정수만 받는다 — 비트는 기계 낱말의 성질이므로, 그 성질이 없는 값에는 뜻이 없다. 이 어긋남은 실행 자리에서 잡힌다(E-BITOP-TYPE).

3 옮기는 칸수가 그 타입의 폭보다 작지 않음이 증명되면 거부된다(E-SHIFT-RANGE).

6.3.6 넘쳤을 때 어떻게 할지 **이름으로 고른다**

1 add·sub·mul 은 넘치면 멈춘다(§6.3.4). 다른 처분이 필요하면 그 처분이 이름에 적힌 op 을 쓴다. 곧 처분은 설정이 아니라 낱말이다.

2 나눗셈의 0 도 같다. 제수가 0 이 아님이 타입으로 보장된 자리에서는 div_nz 를 쓰며, 그 자리에는 검사가 남지 아니한다.

2a 그 보장을 얻는 길이 nonzero_of 다. nonzero_of <값> 은 그 값이 0 이 아님을 값으로 알린다(⟦option⟧) — 0 이면 없음이다. 한 번 얻은 뒤에는 나누는 자리마다 다시 묻지 아니한다.

3 폭을 줄이는 일도 처분을 이름으로 고른다.

6.3.7 레인을 다루는 op

1 vec(§6.2.11)은 산술을 레인마다 따로 하지만, 레인을 가로지르는 일은 op 으로 따로 있다.

1a splat 은 레인 수를 선언된 타입에서 받는다. 그래서 쓸 수 있는 자리는 벡터 타입을 적은 바인딩의 값 자리뿐이다: var lim vec u32 4 be splat 5 .. 식 안에 바로 적는 것은 적합하지 아니하다(E-VEC-SPLAT) — 그 자리에는 레인 수를 말해 주는 것이 없다.

2 레인을 가로지르는 op 은 레인 수만큼을 하나로 모은다. 결과의 타입은 레인의 타입이다.

6.3.7.1 조각을 더한다

1 조각(⟦slice⟧)에 담긴 부동소수를 모두 더하는 op 은 둘이며, 이름이 어떻게 더하는지를 말한다.

1a sum_neumaier <조각> 은 더하며 잃은 자리를 따로 모아 되돌린다. 그래서 오차가 항의 개수에 매이지 아니한다.

1b sum_seq <조각> 은 앞에서 뒤로 한 번 더한다. 빠르고, 오차가 항의 개수에 비례한다.

module ex_slice_sum .

type bytes slice u8 . .

fn total input b bytes . output u64 .
do
  var xs slice f64 . be view_array f64 b .
  return sum_neumaier xs .      rem 결과는 부동소수인데 머리는 `u64` 라고 적었다
end

2 두 op 의 결과는 부동소수다. 정수로 적은 자리에 그대로 돌려주면 거부된다 (E-TYPE-RETURN).

6.3.8 크기를 묻는다 — `size_of`

1 size_of <타입> 은 그 타입 값 하나가 차지하는 바이트 수를 번역 시점에 준다.

2 크기를 알 수 없는 타입에는 쓸 수 없다.

6.3.9 초월 함수

1 sin · cos · exp · log · pow · sqrt · abs · floor · ceil · round · fmod 는 부동소수 전용이다.

2 이들은 권한을 요구하지 아니하며, 운영체제가 있는 기계에서만 쓸 수 있다.

6.3.10 참거짓은 수가 아니다

1 and · or · not 은 참거짓만 받는다. 정수를 건네면 거부된다 (E-TYPE-LOGICAL).

2 조건이 오는 자리(§6.5)도 마찬가지로 참거짓만 받는다(E-TYPE-COND).

3 곧 0 이 거짓이고 그 밖이 참이라는 약속은 없다. 무엇을 묻는지는 그 자리에 적어야 한다 — gt a 0 처럼.

module ex_cond .

fn f input a u8 . output u8 .
do
  if a . do return 1 . end     rem 무엇을 묻는지 적는다 — `gt a 0`
  return 0 .
end

6.3.11 폭과 레인은 타입의 일부다

1 레인 수가 다른 두 vec 은 서로 다른 타입이며 섞이지 아니한다(E-TYPE-LANES).

2 가림막을 받는 자리에는 가림막만 올 수 있다(E-TYPE-MASK).

3 묶음의 칸 배치가 같아도 이름이 다르면 다른 타입이다(E-TYPE-WRAP) — 같은 배치가 같은 타입을 만들지 아니한다(§8.9).

4 좁힌 범위(§6.2.14)를 벗어난 값을 그 자리에 두면 거부된다(E-TYPE-RANGE). 어떤 값도 만족시킬 수 없는 범위를 적는 것도 마찬가지다 — 그것은 조건이 아니라 거짓말이다.

module ex_lanes .

fn f input a vec u8 4 . input b vec u8 8 . output vec u8 4 .
do
  return add a b .
end

6.3.12 `expr` 섬 안의 규칙

1 expr 섬(§6.3.2) 안에서 op 을 부르려면 괄호로 묶어야 한다 (E-EXPR-APP) — 섬 안은 중위 표기이고, 괄호가 없으면 어디까지가 한 부름인지 읽는 이도 처리기도 가릴 수 없다.

2 섬 안에는 중위 연산자만 있다. 앞에 붙는 한 자리 연산자는 없다 (E-EXPR-UNARY) — 부호를 뒤집으려면 그렇게 적힌 op 을 괄호로 부른다.

module ex_island .

fn g input a u8 . output u8 . do return a . end

fn f output u8 .
do
  return expr g 1 .     rem `expr (g 1)` 이어야 한다
end

6.4.1 op 의 선언

1 op (op) 은 이름과 계약을 가진 실행 단위다. op 은 두 갈래로 갈린다.

fn (pure op)

아무 효과도 내지 않는 op. 같은 입력에 언제나 같은 결과를 낸다. 바깥세상을 건드리지 않으므로 순서를 바꾸어 실행해도 결과가 같다.

proc (effectful op)

효과를 내는 op. 무슨 효과를 내는지 자기 계약에 적어야 하며(§7.1), 적은 것보다 많은 효과를 내면 번역이 거부된다.

2 갈래는 언제나 적는다. 기본값이 없다 — fn 인지 proc 인지는 이름 앞에 적혀 있다.

3 op 의 선언은 이름, 입력, 출력, 효과, 계약, 본문의 차례로 이루어진다. 입력은 input, 출력은 output 으로 적는다. 차례는 앞의 것이 뒤의 것에 쓰이도록 놓였다:

• 이름 붙은 약속(satisfies)은 이름 바로 뒤에 온다 — 이 op 이 무엇인지를 먼저 말한다.
• 번역 시점 입력(comptime)이 다음이다 — 뒤따르는 입력·출력의 타입이 그 이름을 쓴다.
• 권한 입력이 데이터 입력보다 먼저다 — 누가 허락했는지가 무엇을 받는지보다 먼저 보인다.
• 출력은 입력 뒤다 — 출력 타입은 입력의 타입 매개변수를 쓸 수 있다.
• 효과는 출력 뒤, 계약 앞이다 — 앞에 받은 권한으로 무엇을 하는지를 적는다.
• 계약은 입력 조건(requires) · 출력 약속(ensures) · 실패(errors) · 시험(tests) 차례다.

3a 머리의 절은 한 가지 차례로만 적는다. 앞에서 뒤로: satisfies·lowdoc · vector·priority · comptime 입력 · 권한·영역 입력(타입이 cap …·region …) · using · 데이터 입력 · output · effects · link·variadic · asm·absorbs·reference·why · access·inplace·invalidates·parallel·reduce · requires · ensures · errors · tests · schedule. 같은 자리의 절끼리는 적힌 차례를 지킨다. trait 의 메서드 서명(§6.11.2)과 actor 안의 proc 도 같은 차례를 따른다. 이 차례를 어기면 번역이 거부된다(E-CLAUSE-ORDER). 입력의 차례는 부르는 쪽 인자의 차례이기도 하다 — 그러므로 권한은 언제나 데이터보다 먼저 건넨다.

3b 서식기(--fmt)는 입력이 아닌 절과 using 을 이 차례로 옮겨 적는다. 입력끼리의 차례는 옮기지 아니한다 — 입력을 옮기면 호출의 뜻이 바뀌기 때문이다.

3c 머리의 절은 저마다 자기 점으로 닫는다 — 문장과 같다(§6.1.6 (2)). 절 낱말은 앞 절을 닫지 아니하고, 개행도 닫지 아니한다. 점 없이 다음 절 낱말이나 do 를 만나면 번역이 거부된다(E-DOT-MISSING). 절의 목록이 곧 머리이므로, 이름 뒤에 오는 첫 낱말부터 절이다 — 이름이 절 낱말과 같은 철자여도 (proc link …) 이름으로 읽는다.

module ex_op .

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

module ex_clause_order .

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

module ex_clause_dot .

fn twice input n u32 output u32 .
do
  return mul n 2 .
end

6.4.2 계약이란 무엇인가

1 계약 (contract) 은 op 이 자기 입력과 출력에 대해 스스로 적는 약속이다. 계약은 주석이 아니라 검사되는 문장이다.

2 계약은 세 곳에서 쓰인다.

3 가) 처리기가 사실로 쓴다 — 계약이 참임을 전제로 검사를 없앤다(§6.4.5).

4 나) 실행 중에 강제된다 — 처리기가 증명하지 못한 계약은 실행 중에 확인되며, 깨지면 트랩한다. 다만 남은 검사를 실제로 둘지는 빌드 모드가 정한다(§6.4.8).

5 다) 읽는 사람에게 말한다 — 이 op 을 부르려면 무엇을 지켜야 하는지가 본문을 열지 않고도 보인다.

6 계약이 깨지는 자리는 둘이고, 진단이 누구의 잘못인지 가른다.

6.4.3 계약의 여섯 절

1 계약은 다음 여섯 절로 이루어진다. 모든 절이 필수는 아니다.

requires (precondition)

op 에 들어오는 순간 참이어야 하는 조건. 부르는 쪽이 지킬 책임이 있다. 들어올 때 확인되며, 깨져 있으면 트랩한다.

ensures (postcondition)

op 이 정상으로 끝날 때 참인 조건. 만드는 쪽이 지킬 책임이 있다. 돌려주는 값을 ret 이라는 이름으로 가리킬 수 있다.

errors (error condition)

op 이 실패하는 경우와 그때의 오류 값. 어떤 조건에서 어떤 오류가 나오는지를 적는다. 조건은 op 에 들어올 때의 값으로 읽는다 — ⟦(1c)⟧.

effects (effect declaration)

이 op 이 내는 효과의 목록(§7.1). 아무 효과도 내지 않으면 effects none 이다.

access (access declaration)

이 op 이 무엇을 어떻게 건드리는지 — access <이름> <모드> . 로 적는다. 모드는 아래 표의 일곱 가지가 전부이며, 그 밖의 낱말은 거부된다(E-CONTRACT-MODE).

tests (examples)

이 op 의 쓰임새를 보이는 예. 처리기는 이것을 시험으로 돌릴 수 있다.

1a tests <이름>… 절은 이 op 의 쓰임새를 보이는 test 블록의 이름을 하나 이상 적는다. 적은 이름은 같은 단위 안의 test 블록이어야 하며, 그 블록들이 이 op 의 예다. tests 절은 시험을 정의하지 아니한다 — 이미 있는 것을 가리킬 뿐이다.

1b lowdoc 절은 이 op 의 설명을 적는다. 한 줄이면 lowdoc "<글>" . 이고, 여러 줄이면 lowdoc text <끝표시> 로 열어 그 표시가 홀로 있는 줄까지가 글이다. 이 글은 문서 산출물 (--doc)이 읽으며, 번역되는 프로그램의 뜻에는 영향을 주지 아니한다.

1c errors 절의 조건은 op 에 들어올 때의 값으로 읽는다.

1c1 몸통이 그 오류를 한 번도 내지 아니하면 처리기는 그것을 알린다 (W-ERRORS-UNRAISED). 절은 «이 op 이 이렇게 실패할 수 있다» 는 약속으로 읽히고 부르는 쪽이 그것을 보고 갈래를 짓는데, 갈 수 없는 갈래는 읽는 사람이 살아 있는 갈래와 가릴 수 없는 죽은 코드가 된다. 남의 result 를 그대로 넘기는 op 은 그 오류를 내는 것으로 본다(try · return <부름>).

1d 그러므로 그 조건에 설 수 있는 이름은 들어올 때와 나갈 때가 같은 것뿐이다 — 곧 바뀌지 않는 입력과 모듈 상수다. 몸통이 바꿀 수 있는 이름(액터의 상태 칸 · 모듈 var · mut 자리의 인자)을 조건에 적으면 거부된다(E-ERRORS-STATE).

2 계약에 쓰는 조건은 순수한 식이어야 한다 — 효과를 내는 것을 계약에 적을 수 없다.

3 shared_read 와 write_only 는 읽기·쓰기의 규율이라 처리기가 지금 강제한다. 곧 shared_read 라 적고 그 자리에 쓰면 거부되고, write_only 라 적고 읽으면 거부된다 (E-ACCESS-MODE). 나머지 다섯은 쓰임새를 알리는 힌트이며, 처리기는 그것을 아직 쓰지 않는다는 것을 말한다(W-NOT-YET). 조용히 무시하지 아니한다.

4 강제되지 않는다고 해서 적어도 좋다는 뜻은 아니다. 모드는 이 op 이 무엇을 하는지에 대한 주장이며, 처리기가 언젠가 그 주장을 물을 수 있다.

6.4.4 계약을 쓰는 법

1 조건은 전위 표기로 적는다. 비교와 논리 연산, 산술, len, index 를 쓸 수 있다.

2 requires 가 여럿이면 모두 참이어야 한다.

3 슬라이스의 모든 원소에 대한 조건은 다음 넷으로 적는다. elem_lt <슬라이스> <값> 은 “모든 원소가 그 값보다 작다” 는 뜻이며, elem_le·elem_gt·elem_ge 도 같다.

4 이 넷이 있는 까닭은 계약이 하나씩 도는 것을 적을 수 없기 때문이다. 조건은 순수한 식이고 되풀이는 문장이므로, 원소 전체를 말하려면 그것을 말하는 낱말이 있어야 한다.

module ex_contract .

rem 이 op 은 슬라이스에서 두 바이트를 읽어 큰 수 하나를 만든다.
export fn read_pair input data slice u8 . . output u32 .
  requires ge (len data) 2 .
  ensures le ret 65535 .
do
  let hi u32 be widen u32 (index data 0) .
  let lo u32 be widen u32 (index data 1) .
  return add (mul hi 256) lo .
end

6.4.5 계약에 이름 주기

1 여러 op 이 같은 조건을 요구하면, 그 조건에 이름을 줄 수 있다. contract 로 적는다.

2 op 은 satisfies 로 그 이름을 적어 그 계약을 갖춘다.

module ex_named .

rem 여러 op 이 같은 조건을 요구하면 그 조건에 이름을 줄 수 있다.
contract nonneg do
  requires ge a 1 .
end

fn half satisfies nonneg . input a u8 . output u8 .
do
  return div a 2 .
end

6.4.6 계약이 검사를 없앤다

1 처리기는 계약을 사실로 삼아 값이 가질 수 있는 범위를 좁힌다. 그 범위가 안전을 보이면 그 검사를 없앤다.

2 없앨 수 있는 검사는 다음이다 — 넘침, 0 으로 나누기, 좁히기, 슬라이스 경계.

3 계약이 강제되지 않으면 사실로 쓰지 아니한다. 곧 확인 없이 믿는 일은 없다. 확인 없이 믿고 검사를 없애면 그것은 빨라진 것이 아니라 틀린 것이다.

4 처리기는 없애지 못한 검사가 어디에 남았는지 알릴 수 있다. 알리지 않는 성능 모형은 그 자체로 소스 밖의 지식이 된다(§1.3).

module ex_elim .

rem 계약이 없으면 넘침 검사가 남는다.
export fn bare input a u8 . output u8 .
do
  return add a 1 .
end

rem 계약이 있으면 처리기가 증명하고 검사를 없앤다.
export fn proven input a u8 . output u8 .
  requires le a 200 .
do
  return add a 1 .
end

6.4.7 빌드 모드가 남은 검사를 정한다

1 빌드 모드 (build mode) 는 소스에 build <모드> . 로 적는다. 증명된 계약은 어느 모드에서도 검사가 남지 아니한다. 정하는 것은 증명하지 못한 계약의 처분이다.

1a 모드는 닫힌 넷이다 — debug · test · release_safe · release_fast. 그 밖의 낱말은 거부된다(E-BUILD-MODE).

2 debug 는 남은 검사를 두고, 깨지면 무엇이 깨졌는지 말하며 멈춘다.

2a test 는 debug 처럼 검사를 두되, 시험(test 선언)을 함께 짓고 돌린다. 시험 안의 expect 가 거짓이면 그 시험은 실패한다(E-TEST-FAIL) — 처리기의 잘못이 아니라 적은 사람의 주장이 틀린 것이다.

3 release_safe 는 남은 검사를 두되 메시지 없이 멈춘다.

4 release_fast 는 남은 검사를 없앤다. 그러므로 이 모드에서 계약이 깨진 채로 프로그램이 계속 진행할 수 있으며, 그때의 거동은 이 문서가 정하지 아니한다.

5 곧 release_fast 는 신뢰 경계(§4.4)를 하나 더 여는 것과 같다 — 계약이 참임을 사람이 약속하는 것이다.

module ex_build_mode .

build nosuchmode .

fn f output u8 . do return 1 . end

6.4.8 이름과 범위

1 이름은 네 겹으로 중첩된다 — 모듈, op, 블록, 그 안의 블록.

2 한 이름은 한 범위에서 정확히 한 대상을 가리킨다. 이미 살아 있는 이름을 다시 선언하여 가릴 수 없다. 그렇게 하면 번역이 거부된다.

3 가릴 수 없는 것은 다음 넷이다 — 모듈에 있는 이름, 내장 연산의 이름(§6.1.3), 같은 op 의 매개변수 이름, 그리고 바깥 블록에서 아직 살아 있는 지역 이름.

4 같은 블록에서 같은 이름을 두 번 선언하는 것도 적합하지 아니하다. 두 번째 선언은 첫 번째를 대신하지 않는다 — 같은 글자가 두 대상을 가리키게 될 뿐이다.

5 블록을 벗어나면 그 블록에서 선언한 이름은 사라진다. 따라서 나란한 두 블록이 같은 이름을 각각 선언하는 것은 적합하다 — 두 이름이 동시에 살아 있지 않기 때문이다.

module ex_shadow .

let g u32 be 7 .

proc p output u32 . effects none .
do
  let g u32 be 1 .     rem 모듈의 `g` 를 가린다
  return g .
end

module ex_shadow_param .

proc p input n u32 . output u32 . effects none .
do
  let n u32 be 1 .     rem 매개변수 `n` 을 가린다
  return n .
end

module ex_shadow_twice .

proc p output u32 . effects none .
do
  let a u32 be 1 .
  let a u32 be 2 .     rem 첫 번째를 대신하지 않는다
  return a .
end

module ex_shadow_inner .

proc p input n u32 . output u32 . effects none .
do
  let a u32 be 1 .
  guard gt n 0 . else do
    let a u32 be 2 .   rem 바깥 `a` 가 아직 살아 있다
    return a .
  end
  return a .
end

6 이름을 찾는 차례는 지역 → 모듈 → 가져온 모듈이다. 가져온 이름이 서로 부딪히면 어느 것인지 밝혀 적어야 한다.

6.4.9 계약의 등급

1 계약 절 하나에 등급 (grade) 을 붙여 그 조건을 언제 무엇으로 다룰지를 정할 수 있다 — requires <등급> <조건> . 처럼 절 낱말 바로 뒤에 온다. 등급은 다음 셋이 전부다.

등급 (grade)

계약 절 하나에 붙여 그 조건을 언제 누가 책임지는지를 정하는 표시. 번역할 때 처리기가 증명하거나(static), 돌 때 검사하거나(debug), 사람이 참이라고 약속한다(assume).

2 등급을 적지 아니하면 처리기가 정한다 — 증명할 수 있으면 증명하고, 못 하면 빌드 모드(§6.4.7)가 정한 대로 남긴다. 곧 등급은 기본 처분을 뒤집는 표시이지 계약을 쓰는 데 필요한 것이 아니다.

3 assume 한 조건은 사실로 쓰이지 아니한다. 처리기는 그것을 지키지도 않고, 그것에 기대어 다른 검사를 지우지도 않는다 — 곧 그 조건은 읽는 사람에게 하는 말이다.

4 이것이 규범인 까닭은 그 반대가 성립하지 아니하기 때문이다. 지켜지지 않는 조건을 사실로 삼으면, 그 조건이 거짓일 때 처리기는 지우지 말았어야 할 검사를 지운 채 옳다고 믿는다. 곧 계약을 사실로 쓰려면 강제해야 하고, 강제하지 않는 것은 사실이 아니다.

module ex_mode_debug .

build debug .

fn bump input a u8 . output u8 .
  requires le a 200 .
do
  return add a 1 .
end

bump(10) = 11 · bump(250) → E-VM-CONTRACT (트랩)

module ex_mode_fast .

build release_fast .

fn bump input a u8 . output u8 .
  requires le a 200 .
do
  return add a 1 .
end

bump(10) = 11 · bump(250) = 251 (멈추지 않는다)

6.4.10 지금 판정할 수 있는 위반

1 부르는 자리가 상대의 requires 를 어기고 양쪽이 모두 상수이면, 그 어김은 실행을 기다릴 필요 없이 번역할 때 판정된다. 이때 거부된다 (E-CONTRACT-IMPOSSIBLE).

2 이것은 계약을 더 엄하게 만든 것이 아니라, 언제 답이 나오는가를 앞당긴 것이다. 전에는 초록으로 번역되어 실행 중에 덫에 걸렸다.

module ex_impossible .

fn g input a u8 . output u8 . requires lt a 10 .
do
  return a .
end

fn f output u8 .
do
  return g 200 .       rem 200 은 결코 10 보다 작지 않다
end

6.4.11 이름이 될 수 없는 것

1 가릴 수 없는 것(§6.4.8)과는 별개로, 애초에 이름이 될 수 없는 글자들이 있다.

1a 여기서 「내장 연산」은 §6.3 이 이름 부른 것들만이 아니다. 호스트에 닿는 잎(파일·그물·디렉터리·경로·시각·난수 …)의 이름도 그 집합에 든다. 그 이름들이 무엇을 하는지는 이 문서가 적지 아니하나(§9.5 — 목록은 베끼지 않는다), 이름이 잡혀 있다는 사실은 규범이다 — 지역 이름으로 쓰면 거부된다.

2 들여온 이름 둘이 같은 이름에 묶이는 것도 거부된다(E-NAME-COLLISION). 들여오기는 이미 있는 이름을 덮어쓰지 아니한다.

3 점이 든 이름 <앞>.<뒤> 에서 앞은 선언된 타입이어야 한다(E-NAME-QUALIFIER). 그 모양은 op 을 그 타입의 이름칸에 두는 것이지 모듈을 가리키는 것이 아니다.

6.4.12 계약이 가리키는 것

1 계약 절이 부르는 이름은 그 자리에서 볼 수 있는 것이어야 한다. 없는 이름을 부르면 거부된다(E-REQ-UNDEF · E-ENS-UNDEF).

2 처리기가 그 자리로 가져올 수 없는 것을 부르는 계약도 거부된다 (E-REQ-UNSUP · E-ENS-UNSUP). 판단할 수 없는 것을 판단한 척하지 아니한다.

3 이름 붙인 계약(§6.4.5)이 선언되지 않은 것을 가리키면 거부된다 (E-CONTRACT-UNDEF).

4 일어날 수 없는 오류를 선언하는 것은 거부된다(E-CONTRACT-DEAD) — requires 가 이미 그 경우를 걸러 내고 있다면, 그 오류 갈래는 결코 나지 아니한다.

4a 같은 입력에 대한 requires 둘이 함께 참일 수 없으면 거부된다 (E-CONTRACT-UNSAT) — 어떤 인자로 불러도 진입에서 멈추므로 그 op 의 몸은 결코 돌지 아니한다. (4) 와 같은 자리다: 돌지 않는 코드가 시그니처에 적혀 있는 것이다.

4b 처리기가 강제하지 못하는 계약 절은 그 사실을 알린다(W-CONTRACT-IGNORED). 진입 검사(requires)와 출구 검사(ensures)가 각각 아는 모양이 있고, 그 밖의 모양은 실행 중에 아무도 막지 않으며 구간 분석도 배우지 못한다. 그 절은 문서에만 선다.

5 번역 시점의 매개변수에 건넨 타입이 그 자리가 요구하는 것을 갖추지 못하면 거부된다(E-BOUND-UNSAT, §6.11.2).

6.5.1 이름을 짓는 문장

1 let 은 바뀌지 않는 이름을 짓는다. 한 번 정해진 값은 바뀌지 아니한다.

2 var 는 바뀔 수 있는 이름을 짓는다. set 으로 값을 바꾼다.

2a 매개변수도 set 할 수 있다. 값으로 받은 매개변수는 이 op 안의 지역 복사이므로, 그것을 바꾸어도 부른 쪽의 값은 바뀌지 아니한다. 부른 쪽에 닿는 쓰기는 mut·mut_ref 자리뿐이다(§8.4).

2b 그러므로 requires·ensures 가 매개변수 이름으로 말하는 것은 들어올 때의 값이다. 몸통이 그 이름을 set 한 뒤에도 계약이 말하는 것은 들어올 때의 값 그대로다.

3 이름을 지을 때 타입을 함께 적을 수 있다. 적으면 그 타입이 되고, 값이 그 타입에 맞지 않으면 번역이 거부된다.

3a 타입을 생략할 수 있다. 생략하면 값이 타입을 정한다. 값에서 타입을 정할 수 없으면 번역이 거부되며, 그때는 적어야 한다.

4 be 뒤에는 값이 있어야 한다. 값 없이 닫으면 번역이 거부된다(E-LET-NOVALUE). 이름을 짓되 값을 나중에 주는 길은 이 언어에 없다.

module ex_let_novalue .

fn f output u8 .
do
  let a u8 be .        rem 조용히 0 을 넣지 아니한다
  return a .
end

6.5.2 조건 — `if`

1 if 는 조건이 참일 때 블록을 실행한다. 조건은 bool 이어야 한다(§6.2.3).

2 else 로 거짓일 때의 블록을 적을 수 있다.

3 블록은 do 로 열고 end 로 닫는다.

3a else 는 앞 블록을 end 로 닫은 뒤에 온다: if <조건> . do … end else do … end. else 를 블록 안에 두는 것은 적합하지 아니하다(E-STMT-ELSE).

4 if 는 문이다. 값을 내는 식으로 쓸 수 없다(E-IF-VALUE) — 갈래마다 값을 정하려면 각 갈래에서 이름에 set 하거나 return 한다.

module ex_if_value .

fn pick input a u64 . output u64 .
do
  let x u64 be if gt a 1 . 5 else 6 .   rem 갈래마다 set 하거나 return 한다
  return x .
end

6.5.3 되풀이 — `while`

1 while 은 조건이 참인 동안 블록을 되풀이한다.

2 break 는 되풀이를 벗어나고, continue 는 다음 바퀴로 넘어간다.

2a 그 둘은 되풀이 안에서만 쓴다. 되풀이 밖에 적는 것은 적합하지 아니하다 (E-LOOP-OUTSIDE) — 벗어날 되풀이가 없다.

3 되풀이의 조건도 bool 이어야 한다.

module ex_ctl .

export fn count_big input n u32 . output u32 .
  requires le n 100 .
do
  var total u32 be 0 .
  var i u32 be 0 .
  while lt i n . do
    if gt i 5 . do
      set total (add total 1) .
    end
    set i (add i 1) .
  end
  return total .
end

4 for 는 슬라이스의 원소를 차례로 훑는다 — for <이름> <슬라이스> do … end. 이름은 원소 하나를 가리키며, 그 타입은 슬라이스의 원소 타입이다. 훑는 대상이 슬라이스가 아니면 번역이 거부된다(E-TYPE-ITER).

5 for 의 이름은 블록 안에서만 산다. 블록이 끝나면 그 이름은 없다.

6 break 와 continue 는 for 안에서도 while 에서와 같이 쓴다.

module ex_for .

export fn total_of input xs slice u8 . output u64 .
do
  var acc u64 be 0 .
  for x xs do
    set acc (add acc (widen u64 x)) .
  end
  return acc .
end

원소를 모두 더한다

6.5.4 빠져나가는 조건 — `guard`

1 guard 는 조건이 참이 아니면 그 자리에서 빠져나간다. else 뒤에 오는 것은 모든 길이 빠져나가야 한다.

1a else 뒤에는 한 문장이 올 수도 있고 블록이 올 수도 있다. 블록이면 그 블록의 모든 길이 빠져나가야 한다 — 빠져나가는 문장은 return, break, continue, panic 이다.

2 else 의 어떤 길이 빠져나가지 않고 아래로 이어지면 번역이 거부된다.

3 guard 를 지나면 그 조건은 참임이 보장된다. 처리기는 그 뒤의 코드에서 그 사실을 쓴다.

module ex_guard_bad .

proc p input n u32 . output u32 . effects none .
do
  guard le n 5 . else set n 0 .   rem 빠져나가지 않고 아래로 이어진다
  return n .
end

module ex_guard .

export fn safe_head input data slice u8 . . output u8 .
do
  guard ge (len data) 1 . else return 0 .
  return index data 0 .
end

module ex_infer_guard .

rem 타입을 적지 않아도 된다 — 값이 정한다.
fn inferred output u64 .
do
  let a be 7 .
  return a .
end

rem `else` 가 블록이어도 된다. 규칙은 "모든 길이 빠져나가는가" 다.
fn guarded input n u8 . output u8 .
do
  guard gt n 5 . else do
    let x u8 be 1 .
    return x .
  end
  return 9 .
end

inferred() = 7 · guarded(3) = 1 · guarded(9) = 9

module ex_guard_fall .

fn f input n u8 . output u8 .
do
  guard gt n 5 . else do
    let x u8 be 1 .
  end
  return 9 .
end

6.5.5 돌아가기 — `return`

1 return 은 op 을 끝내고 값을 돌려준다. 돌려주는 값의 타입은 output 에 적은 것과 같아야 한다.

1a 이 규칙은 return 이 어디에 있든 같다 — guard 의 else 뒤의 한 문장과 else 블록 안의 모든 문장도 같은 검사를 받는다. 그래서 output result … 인 op 은 ok <값> · error <변형> · result 를 내는 식으로만 돌아가고, 맨값을 돌려주면 거부된다 (E-TYPE-RETURN). 반대로 맨 타입을 적은 op 이 ok <값> 을 돌려주는 것도 거부된다.

module ex_bare_under_result .

enum short do
  too_short .
end

fn head input b slice u8 . . output result u8 short .
errors too_short .
do
  guard ge (len b) 2 . else return 0 .   rem `ok 0` 도 `error too_short` 도 아니다
  return ok (index b 0) .
end

2 값을 돌려주지 않는 op(output void)은 return 만 적어 일찍 끝낼 수 있다.

2a 값을 돌려주지 않는 op 은 return 없이 몸의 끝까지 진행해도 된다. 돌려줄 값이 없으므로 끝나는 자리가 곧 돌아가는 자리다.

3 값을 돌려주는 op 은 모든 길이 값을 돌려주고 끝나야 한다. 값 없이 끝나는 길이 있으면 적합하지 아니하다.

4 다음 문장은 값을 돌려주고 끝나는 것으로 본다 — return, 두 갈래가 모두 값을 돌려주는 if⋯else, 그리고 모든 갈래가 값을 돌려주는 match. match 가 모든 경우를 덮는지는 따로 검사된다(§6.6).

5 guard·while·for 는 빠져나가는 길이 있으므로 그 자체로는 값을 돌려주는 것으로 보지 아니한다.

6 몸이 기계 명령인 op(§6.9)은 값을 out reg 로 내므로 이 조항의 대상이 아니다.

module ex_void .

proc keep input n u8 . output void . effects none .
do
  let x u8 be n .
end

6.5.6 블록과 들여쓰기

1 블록은 do 로 열고 end 로 닫는다. 들여쓰기는 뜻이 없다 — 읽는 사람을 위한 것이다.

2 블록 안에서 지은 이름은 그 블록 안에서만 보인다. 블록이 닫힌 뒤에 그 이름을 읽는 것은 적합하지 아니하다(E-NAME-SCOPE) — 들어가지 아니한 길에서는 그 이름에 값이 놓인 적이 없으며, 처리기가 0 을 대신 놓지 아니한다(§6.5.5 (3)).

module ex_name_scope .

fn pick input a u64 . output u64 .
do
  if gt a 1 . do
    let big u64 be mul a 2 .
  end
  return big .        rem 들어가지 아니한 길에는 `big` 이 없다
end

6.5.7 실패를 말하는 세 가지 길

1 실패를 말하는 길은 셋뿐이며, 쓰임이 서로 다르다.

2 result 의 오류 타입에 들어가는 변형은 그 op 의 errors 절이 적은 것과 같아야 한다. 적지 않은 오류를 돌려주거나, 적어 놓고 안 돌려주는 것은 적합하지 아니하다.

3 panic 은 되돌아 풀리지 아니한다. 멈추는 자리에서 프로그램이 끝난다 — 중간에 잡아 이어 가는 길은 없다.

module ex_channels .

enum io_error do
  too_big .
end

rem ① 고칠 수 있는 실패 — result.
fn halve input a u8 . output result u8 io_error .
  errors too_big gt a 200 .
do
  guard le a 200 . else return error too_big .
  return ok (div a 2) .
end

rem ② 값이 없음 — option.
fn lookup input k u8 . output option u8 . .
do
  guard lt k 3 . else return none .
  return some (mul k 10) .
end

rem ③ 계약이 깨짐 — 부르는 쪽이 약속을 어기면 멈춘다.
fn strict input a u8 . output u8 .
  requires le a 200 .
do
  return add a 1 .
end

halve(100) = ok 50 · halve(250) = err too_big · lookup(2) = some 20 · lookup(7) = none · strict(10) = 11 · strict(250) → 트랩

6.5.8 실패를 다루기 — `try` 와 소비형

1 result 를 돌려주는 op 을 부를 때, try 는 성공하면 값을 꺼내고 실패하면 그 오류를 그대로 위로 넘긴다.

2 try 를 쓰는 op 은 자기도 그 오류를 돌려줄 수 있어야 한다. 아니면 거부된다 (E-TRY-NORESULT) — 실패가 갈 곳이 없기 때문이다. 꼬리를 붙여 채널을 바꾸거나((4)), (3) 의 방법으로 여기서 다루면 그 op 은 result 를 돌려주지 않아도 된다.

3 result 와 option 을 소비하는 방법은 다음으로 닫혀 있다 — try(꼬리를 붙인 것도 포함한다, (4)) · 묻는 것(is_ok is_error is_some is_none) · 꺼내는 것 (ok_value error_value some_value) · 대신 쓸 값을 주는 것(value_or).

4 try 뒤에 꼬리를 붙여 채널을 바꿀 수 있다. 값은 그대로이고 담는 그릇만 바뀐다.

5 채널 전환은 타입을 바꾼다. try <식> else_none 을 적은 자리의 타입은 option 이지 그 안의 값이 아니다. 값 타입을 적어 놓고 채널 전환을 쓰면 적합하지 아니하다.

6 꺼내는 것은 부분 연산이다(§6.2.8). 없는 쪽을 꺼내면 트랩한다.

7 value_or 의 기본값은 값이 없을 때만 평가된다(지연평가). 그러므로 기본값 자리에는 비싼 계산이나 실패할 수 있는 계산을 적어도 된다 — 값이 있으면 그것은 돌지 아니한다.

6.5.9 멈추기 — `panic`

1 panic 은 프로그램을 즉시 멈춘다(§5.4). 이것은 효과이므로, 쓰는 op 은 자기 계약에 그 효과를 적어야 한다.

2 순수한 op(fn)은 panic 을 쓸 수 없다. 다만 계약이 깨졌을 때 처리기가 일으키는 트랩은 이와 별개이며, 그것은 op 이 한 일이 아니다.

6.5.10 나누어 도는 되풀이 — `parallel`

1 되풀이에 parallel <조각> split . 절을 붙이면, 그 되풀이를 조각을 나누어 여럿이 함께 돌 수 있다고 밝히는 것이다.

2 처리기는 그 말을 믿지 아니하고 확인한다. 확인하는 것은 되풀이의 각 걸음이 서로에게 기대지 않는다는 것이며, 조건은 셋이다.

3 parallel 이 조각을 이름 부르는데 그 조각의 길이로 도는 되풀이가 없으면 거부된다 (E-PAR-NOLOOP) — 나눌 것이 무엇인지 알 수 없기 때문이다.

4 모으는 연산은 묶음의 차례를 바꿔도 답이 같아야 한다. 그렇지 않은 연산은 거부된다 (E-PAR-ASSOC). 부동소수의 덧셈은 그렇지 않으므로 따로 막는다(E-PAR-FLOAT).

4a 쌓는 자리의 시작값은 그 연산의 항등원이어야 한다. 아니면 거부된다(E-PAR-IDENTITY). 나누어 돌면 조각마다 그 시작값에서 다시 시작하므로, 항등원이 아닌 값은 조각 수만큼 셈에 들어간다 — 곧 나눈 답이 하나씩 돈 답과 달라진다(위 (2) 의 약속이 깨진다). 항등원은 add·bit_or·bit_xor 가 0, mul 이 1, 부호 없는 폭의 max 가 0 이다.

6.5.11 몸이 갖추어야 하는 것

1 값을 내놓겠다고 적은 op 은 모든 길에서 값을 내놓아야 한다(E-RETURN-PARTIAL). 어느 한 길이 값 없이 끝에 닿으면 적합하지 아니하다.

2 선언의 머리(fn·proc·on·test …)에는 do … end 몸이 있어야 한다 (E-STMT-NODO).

3 맨 바깥 자리에 오는 것은 선언의 머리로 시작해야 한다(E-TOPLEVEL).

4 폼 안에 올 수 없는 것이 오면 거부된다(E-FORM-UNEXPECTED). 머리 자리에 op 이 아닌 이름이 오는 것도 그렇다(E-HEAD-NOT-AN-OP).

module ex_partial .

fn f input a u8 . output u8 .
do
  if gt a 5 . do return 1 . end
end                      rem `a` 가 5 이하인 길에는 값이 없다

6.5.12 오류는 적은 것만 난다

1 op 이 내는 오류는 errors 절이 적은 것 안에 있어야 한다(E-ERR-UNDECLARED).

2 errors 절이 그 op 의 오류 타입에 없는 이름을 적는 것도 거부된다 (E-ERR-UNDEF).

3 다른 op 의 실패를 넘겨 올리면 — try <op> 로, 또는 return <op> … 로 그 result 를 그대로 돌려주면 — 그 op 의 실패가 이 op 의 실패가 된다. 그래서 부른 op 이 낼 수 있는 오류가 이 op 의 errors 절(절이 없으면 이 op 의 오류 타입) 안에 있어야 한다 (E-ERR-UNDECLARED).

3a 부른 op 이 낼 수 있는 오류는 그 op 의 errors 절이 적은 것이다. 절이 없으면 그 op 의 오류 타입 전체다 — 절을 적지 않는 것은 «이 타입의 오류는 무엇이든 날 수 있다» 는 뜻이고, 부르는 쪽도 그 뜻 그대로 읽는다.

module ex_err_undeclared .

enum e do
  bad .
end

fn f output result u8 e .
do
  return error bad .   rem `errors bad …` 를 적지 않았다
end

module ex_err_handed_on .

enum parse_error do
  bad_digit .
end

enum load_error do
  too_long .
end

fn read_digit input c u8 . output result u8 parse_error .
errors bad_digit .
do
  guard le c 9 . else return error bad_digit .
  return ok c .
end

fn load_byte input c u8 . output result u8 load_error .
errors too_long .
do
  guard le c 200 . else return error too_long .
  return read_digit c .     rem `bad_digit` 은 `load_byte` 의 약속에 없다
end

module ex_err_clauseless .

enum parse_error do
  bad_digit .
end

enum load_error do
  too_long .
end

fn read_digit input c u8 . output result u8 parse_error .
errors bad_digit .
do
  guard le c 9 . else return error bad_digit .
  return ok c .
end

fn digit_or_fail input c u8 . output result u8 parse_error .
do
  return read_digit c .     rem 절이 없다 — `parse_error` 의 무엇이든 날 수 있다
end

fn load_byte input c u8 . output result u8 load_error .
errors too_long .
do
  guard le c 200 . else return error too_long .
  let v u8 be try digit_or_fail c .     rem `parse_error` 는 `load_byte` 의 약속에 없다
  return ok v .
end

6.7 시험 — `test` 와 `expect`

1 test 블록은 그 모듈의 시험을 적는 자리다. 처리기는 이것을 돌릴 수 있다.

2 expect 는 시험의 단언이다. 조건이 거짓이면 그 시험이 실패한다.

3 처리기는 expect 를 최적화로 없애지 아니한다. 사라진 시험은 돌지 않은 시험이다.

4 번역만 하는 것은 시험을 돌리지 아니한다. 번역이 통과했다는 것은 “시험이 통과했다” 가 아니다.

module ex_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 .
end

6.8 번역 시점의 매개변수 — `comptime`

1 comptime 을 붙인 매개변수는 번역 시점에 값이 정해져야 한다. 타입도 그렇게 받을 수 있다.

2 같은 op 을 여러 타입에 쓰려면 이 방법을 쓴다. 처리기는 쓰인 조합마다 실물을 만든다.

3 그 만들어짐은 소스에 보인다. 꺾쇠도 없고 추론도 없다 — 어떤 조합이 만들어졌는지가 부르는 자리에 적혀 있다.

4 comptime 자리에 번역 시점에 알 수 없는 값을 주면 적합하지 아니하다.

4a 타입을 받는 comptime 자리를 비워 두는 것도 적합하지 아니하다(E-MONO-NOTYPE). 인자의 타입에서 되짚지 아니한다 — (3) 이 말하듯 무엇이 만들어지는지는 부르는 자리에 적혀 있어야 한다.

5 쓰인 조합마다 실물이 만들어지므로, 조합의 수가 곧 만들어지는 코드의 양이다. 이 비용은 부르는 자리에서 셀 수 있다.

module ex_comptime .

fn twice input comptime n u8 . input a u8 . output u8 .
do
  return add a n .
end

fn use output u8 .
do
  return twice 3 4 .
end

use() = 7

module ex_comptime_rt .

fn twice input comptime n u8 . input a u8 . output u8 .
do
  return add a n .
end

fn use input k u8 . output u8 .
do
  return twice k 4 .
end

6.8.1 번역 시점에 셀 수 있어야 한다

1 comptime 자리의 식은 번역할 때 값이 나와야 한다. 지금의 처리기가 그것을 셈하지 못하면 거부된다(E-COMPTIME-NONCONST).

2 모듈 자리의 let 은 이름 붙인 상수다. 그 값도 번역 시점에 나와야 한다 (E-CONST-NOTCOMPTIME).

module ex_comptime .

fn f input a u8 . output u8 .
do
  let b u8 be comptime a .    rem `a` 는 실행할 때에야 정해진다
  return b .
end

6.9 검사할 수 없는 자리 — `unsafe` 와 `extern`

1 unsafe 는 언어가 검사할 수 없는 일을 하는 자리를 표시한다. 이것은 효과이므로 계약에 적어야 하며(§7.1), 부르는 쪽으로 번져 올라간다.

2 extern 은 다른 언어로 쓴 것과 만나는 자리를 표시한다(§7.4).

3 이 두 자리는 좁아야 한다. 넓히면 그만큼 언어의 보장이 닿지 않는 넓이가 는다.

6.9.1 기계 명령을 직접 쓰는 자리 — `asm`

1 op 의 몸을 기계 명령으로 쓸 수 있다. asm <기계> . 절을 선언에 적고, 몸에는 그 기계의 어셈블리를 적는다.

2 처리기는 그 안을 읽지 못한다. 어셈블러가 읽는다. 곧 이 언어가 지키는 모든 불변이 그 안에서 깨질 수 있고, 처리기는 그것을 볼 수 없다. 볼 수 없는 것은 가둔다 — 다음 넷을 모두 갖추어야 한다.

3 기계 이름은 §5.6 의 닫힌 집합에서 온다. 그 밖의 이름은 거부되며(E-ASM-TARGET), 지금 짓고 있는 기계와 다른 기계의 어셈블리도 거부된다 — 처리기는 그 op 을 조용히 버리지도, 다른 기계의 명령을 어셈블러에 넘기지도 아니한다.

4 피연산자는 <레지스터> <이름> 이 입력이고 out <레지스터> <이름> 이 출력이다. 레지스터만 적고 실을 것을 적지 아니하면 거부된다(E-ASM-OPERAND).

5 clobber 절은 이 명령이 망가뜨리는 것을, options 절은 처리기에게 주는 약속을 적는다.

6 몸은 어셈블리 그 자체다 — 이음글(heredoc) 하나이며 그 밖의 것은 올 수 없다 (E-ASM-BODY). 기계 명령과 낮춘 코드를 섞을 수는 없다.

7 처리기는 템플릿 안을 읽지 못하지만, 피연산자 목록과 템플릿의 {이름} 은 같은 것을 말하는 두 표현이므로 그 둘이 맞는지는 양쪽으로 검사한다.

8 options pure 는 “이 어셈블리에는 곁효과가 없다” 는 말이며, 그 말을 믿고 처리기는 이 명령을 지우거나·끌어올리거나·두 번 대신 한 번만 돌릴 수 있다. 그런데 효과 줄이 입출력·상태·장치를 만진다고 말한다면 둘 다 참일 수 없다. 이때 처리기는 options 를 믿으므로, 어긋남은 거부된다(E-ASM-OPTLIE).

6.9.2 씨와 만나는 자리 — `extern` 의 경계

1 extern 이 붙은 op 은 몸이 씨에 있다. 그러므로 이쪽에 몸을 적으면 거부된다 (E-FFI-BODY) — 몸이 둘인 것은 프로그램이 아니라 아무도 답할 수 없는 물음이다.

1a 몸이 씨에 있는 extern op 은 블록 선언이다. struct 가 칸을 do … end 에 담듯, 절을 do … end 에 담는다: extern proc <이름> do <절>* end. 절은 저마다 자기 점으로 닫는다 (§6.4.1 (3c)). 블록에는 절만 온다 — 문장이 오면 몸이 둘이다(E-FFI-BODY). do 없이 이름 뒤에 절을 늘어놓고 end 로 닫는 꼴은 거부된다(E-STMT-NODO) — end 는 자기 do 만 닫는다(§6.1.6 (2a)).

module ex_extern_block .

unsafe extern proc c_abs do
  input k cap c .
  input a i64 .
  output i64 .
  effects unsafe .
  link "llabs" .
end

module ex_extern_nodo .

unsafe extern proc c_abs input k cap c . input a i64 . output i64 .
  effects unsafe .
  link "llabs" .
end

2 export extern 은 반대 방향이다. 씨가 우리를 부르므로 몸은 이쪽 것이며, 몸이 없으면 거부된다(E-FFI-BODY).

3 씨를 부르는 op 은 다음 셋을 모두 갖추어야 한다. 하나라도 없으면 거부된다.

3a 권리는 종류로 따진다. cap c 가 아닌 다른 권리(할당기·파일 계통 …)를 받는 것으로는 이 자리가 열리지 아니한다(E-FFI-CAPKIND). 있음이 아니라 무엇인가가 권한을 만든다.

4 경계를 건너는 타입은 씨의 ABI 가 표현할 수 있는 것으로 한정된다. 그 밖의 것 (⟦option⟧ · ⟦result⟧ · 벡터 · 그릇)은 거부된다(E-FFI-TYPE). 씨에는 그런 것이 없고, 처리기는 있는 척하지 아니한다.

4a 저절로 사상되는 것은 조각(slice)뿐이다. slice τ 는 「τ 를 가리키는 포인터」와 「개수」 두 인자가 된다. 폭을 안다 — slice u32 는 uint32_t* 이지 바이트 포인터가 아니다. 그 밖은 모두 손으로 적는다.

4b 권리는 건너가지 아니한다. cap 은 값이 아니라 권한이므로 씨에게 넘길 것이 없다.

5 ABI 이름은 c 하나다. sysv·win64·aapcs64 를 낱말로 두지 아니한다 — 그것들이 묻는 것은 “이 기계에서 씨가 무엇인가” 이고, 그 답은 지을 기계(§5.6)가 이미 정한다. 낱말을 늘리면 같은 것을 말하는 길이 둘이 된다.

6 가변인자는 한쪽 방향뿐이다. 씨의 가변인자 함수는 부를 수 있으나, 씨가 우리 가변인자를 부를 수는 없다 — 인자의 수와 타입을 실행 중에 모르는 채로 하는 일이라 계약이 설 자리가 없다.

7 되부름(callback)에는 새 규약이 없다. export extern op 은 이미 씨가 부를 수 있으므로, 되부름은 그 op 의 주소(unsafe_fn <op>)를 값으로 넘기는 것이다. 문에 들어서는 자리에서 경계 계약을 검사한다.

7a 그러므로 unsafe_fn 이 가리킬 수 있는 것은 export extern 인 op 뿐이다. 그렇지 않은 op 을 가리키면 거부된다(E-FN-NOTEXPORT) — 씨가 부를 수 없는 문의 주소를 건네는 것은 주소가 아니라 물음이다.

7b 되부름으로 쓸 op 은 권한을 요구할 수 없다(E-FN-CAP). 되부름에 들어서는 것은 씨이고, 씨는 건넬 권한이 없다. 권한이 필요한 일은 되부름 밖에서 하고, 되부름 안은 셈만 한다.

7c unsafe_fn 뒤에는 op 의 이름이 와야 하며(E-FN-VALUE), 그 이름의 op 이 실제로 있어야 한다(E-FN-UNDEF).

8 owned τ 를 extern 에 넘기면 책임이 씨에게 옮겨간다. 이쪽의 의무는 그 지점에서 끝나고, 그 뒤의 반납은 씨의 몫이다. 이것이 지켜졌는지는 검증되지 아니한다 — 문 안은 우리가, 문 밖은 씨가 책임진다.

9 생 포인터(§8.5)가 경계에서 어긋나면 거부된다(E-UPTR-TYPE).

10 내보내는 타입은 정렬을 기계에서 받아올 수 없다(E-ABI-TARGET-ALIGN). align machine.cache_line 처럼 적으면 배치가 기계마다 달라지는데, 씨 쪽이 읽는 머리글은 배치가 하나라고 여긴다 — 둘은 아무 말 없이 갈라진다. 내보내는 타입에는 적힌 수로 정렬을 준다(align N .).

6.9.3 기계마다 다른 명령을 쓰는 자리 — `unsafe target`

1 어떤 op 은 특정 명령집합이 있을 때만 뜻이 있다. 그런 op 은 unsafe target <명령집합> 으로 그 사실을 적는다.

2 처리기가 모르는 명령집합 이름은 거부된다(E-TARGET-ISET). 이름은 닫힌 집합이다.

3 이름은 알되 지금 짓는 기계가 그것을 주지 못하면 거부된다(E-TARGET-INTRIN).

3a 이 절이 막는 것은 그 op 이 서는 자리이지 op 하나하나가 아니다. 어떤 잎이 이 울타리 안에 들어야 하는지는, 그 잎의 뜻이 기계에 달려 있을 때만 정해진다 — 어느 기계에서나 같은 값을 내도록 적힌 op 은 이 울타리에 들지 아니한다.

6.10.1 무엇을 내보내나

1 export 를 붙인 것만 다른 모듈이 쓸 수 있다. 붙이지 않은 것은 그 모듈 안에서만 쓴다.

2 곧 감춘 것이 기본이다. 내보내는 쪽이 그것을 적어야 한다.

2a export 는 선언에 붙는다: fn · proc · struct · enum · type · newtype · actor · trait. 모듈 상수(let) · 모듈 변수(var) · test 블록에는 붙지 아니한다(E-TOPLEVEL) — 상수는 모듈의 겉면이 아니고(op 으로 내준다), 시험은 그것을 가진 모듈의 것이다.

2b 내보낸 op 의 서명이 내보내지 않은 이름난 타입(구조체·열거·newtype·액터)을 쓰면 처리기는 그것을 알린다(W-EXPORT-HIDDEN) — 들여온 쪽은 그 타입을 적을 수 없으므로 값을 받을 이름을 지을 수 없고, 그 export 는 밖에서 쓸 수가 없다. 프로그램 자체는 적합하므로 거부가 아니라 알림이다. 투명 별칭(type)은 바탕 타입을 적으면 되므로 여기 들지 아니한다. 거부가 아닌 까닭: 한 모듈만으로 이루어진 단위에서는 「밖」이 없어 그 export 를 쓸 수 없는 이가 아무도 없다. 이 단위가 라이브러리로 쓰일지 프로그램으로 끝날지는 처리기가 알 수 없으므로, 아직 해가 되지 않은 것을 거부하지 아니한다.

module ex_export .

rem `export` 를 붙인 것만 다른 모듈이 쓴다.
export fn visible input n u32 . output u32 .
do
  return mul n 2 .
end

rem 이것은 이 모듈 안에서만 쓴다.
fn hidden input n u32 . output u32 .
do
  return add n 1 .
end

6.10.2 무엇을 가져오나

1 use 는 다른 모듈을 가져온다. 가져올 것이 어디 있는지도 함께 적는다.

2 가져온 모듈의 이름을 통해 그 안의 것을 부른다.

3 가져올 자리에 그 모듈이 없으면 번역이 거부된다.

module <내 모듈 이름> .

use <가져올 모듈 이름> from "<그 모듈의 자리>" .

4 자리를 적지 아니하는 갈래도 있다. 이때 그 모듈은 같은 번역 단위 안에 있어야 한다 — 여러 파일을 한 단위로 넘기면 그 안에서 찾는다.

module <내 모듈 이름> .

use <가져올 모듈 이름> .

4a use <모듈> [from "<자리>"] as <별칭> . 로 그 모듈을 부를 이름을 바꿀 수 있다. 별칭은 모듈 이름이 서는 모든 자리에 선다 — op 을 한정하는 자리(<별칭>.<op>)도, 타입을 적는 자리(<별칭>.<액터>)도 그렇다.

4b 별칭을 적으면 원래 모듈 이름은 그 단위 안에서 서지 아니한다(E-USE-ALIASED). 별칭은 덧이름이 아니라 바꿔 부르기다. 두 이름이 다 서면 같은 모듈을 두 철자로 부르는 코드가 생기고, 읽는 사람이 둘이 같은 것인지 확인해야 한다 — 별칭을 적은 까닭은 원래 이름이 불편해서인데, 그 이름이 계속 서 있으면 별칭이 한 일이 없다.

module <내 모듈 이름> .

use <가져올 모듈 이름> as <별칭> .

5 자리를 적지 아니한 이름이 그 단위 안에 없으면, 처리기는 그 사실을 말하여야 한다. 이 판의 처리기는 경고(W-USE-EXTERNAL)로 말한다 — 모듈을 찾아다니는 검색 경로가 없으므로, 그 이름이 있는지 없는지를 이 단위만 보고는 알 수 없기 때문이다. 그 이름을 실제로 쓰면 그때는 거부된다.

6.10.3 이름이 부딪히면

1 한 모듈 안에서 같은 이름을 두 번 선언할 수 없다. 그렇게 하면 번역이 거부된다.

2 가져온 이름들이 서로 부딪히면, 부르는 자리에서 어느 것인지 밝혀 적어야 한다.

module ex_dup .

fn f output u32 . do return 1 . end
fn f output u32 . do return 2 . end

6.10.4 선언의 차례

1 모듈 안의 최상위 선언은 차례와 무관하다. 뒤에 선언한 op 을 앞에서 부를 수 있고, 서로 부르는 op 도 쓸 수 있다.

2 op 본문 안에서는 그렇지 않다 — 지역 이름은 쓰기 전에 선언해야 한다.

6.11.1 타입에 op 을 붙이기

1 op 의 이름 앞에 타입 이름과 점을 붙이면, 그 op 은 그 타입에 붙은 것이 된다.

2 붙은 op 의 첫 입력은 그 타입의 값이다.

6.11.2 트레이트

1 트레이트 (trait) 는 어떤 타입이 갖춰야 할 op 의 목록이다. 각 op 의 이름과 시그니처를 적는다.

module ex_trait_why .

rem 모양마다 넓이를 구하는 법은 다르다. 그러나 «넓이를 알려 준다» 는 약속은 같다.
trait shape do
  area input s self . output u64 .
end

struct rect do
  satisfies shape .
  w u64 .
  h u64 .
end

struct square do
  satisfies shape .
  side u64 .
end

fn rect.area input s rect . output u64 .
do
  return mul (field s w) (field s h) .
end

fn square.area input s square . output u64 .
do
  return mul (field s side) (field s side) .
end

rem 이 op 은 **어떤 모양이든** 받는다 — `requires shape t` 가 «넓이를 알려 주는 타입만» 이라고 못박는다.
fn double_area input comptime t type . input s t . output u64 .
  requires shape t .
do
  return mul 2 (method s area) .
end

fn demo output u64 .
do
  let r rect be make rect do w 2 . h 3 . end .
  let q square be make square do side 4 . end .
  return add (double_area rect r) (double_area square q) .
end

demo() = 44

1a 트레이트는 op 을 여럿 적을 수 있다. 서명 하나는 op 의 이름으로 시작하고 그 op 의 절이 뒤따르며, 다음 이름이 다음 서명을 연다. 서명마다 한 줄에 적는 것이 관례다. 서명의 절은 op 머리와 같은 차례를 따른다(§6.4.1 (3a)) — 입력 · 출력 · 효과 차례다. 적는 op 의 수에는 한도가 없다.

1b 서명에는 fn·proc 을 적지 아니한다. 그 op 이 무엇을 할 수 있는지는 서명의 effects 줄이 정한다.

• effects 줄이 없으면 효과가 없는 op 이다. 이것은 fn 으로도, 효과를 적은 proc 으로도 갖출 수 있다.

다만 proc 은 effects 줄을 반드시 적어야 한다 — 효과 줄이 없는 proc 은 자기 효과를 좁히지 않은 것이므로 효과 없는 서명을 갖추지 못한다(E-TRAIT-EFFECT).

• effects 줄이 있으면 갖추는 쪽은 그 효과 또는 그보다 적은 효과를 적은 proc 이거나, 효과가 없으면 fn 이다.

2 트레이트 안에서 self 는 그것을 갖출 타입 자신을 가리킨다.

3 타입이 satisfies 로 트레이트를 적으면, 처리기는 그 목록의 op 이 정확히 그 시그니처로 있는지 검사한다. 하나라도 없거나 어긋나면 번역이 거부된다.

4 어긋나는 갈래는 다섯이다.

5 트레이트의 op 이 효과 줄에 via self 를 적으면, 갖추는 쪽은 그 op 에 할당 계열 효과 — alloc · heap · lock · atomic — 를 트레이트보다 더 적을 수 있다. 그 밖의 효과를 더 적는 것은 여전히 E-TRAIT-EFFECT 다. 더 적은 효과는 제네릭 op 이 via <타입 매개변수> 로 부르는 쪽까지 나른다(§7.1.1 (6)).

module ex_trait .

rem 트레이트는 타입이 갖춰야 할 op 의 목록이다.
trait shape do
  area input s self . output u64 . effects none .
end

rem `satisfies` 를 적으면 그 목록을 갖췄는지 검사받는다.
struct rect do
  satisfies shape .
  w u8 .
  h u8 .
end

fn rect.area input s rect . output u64 .
do
  return mul (widen u64 (field s w)) (widen u64 (field s h)) .
end

module ex_trait_bad .

trait shape do
  area input s self . output u64 . effects none .
end

struct rect do
  satisfies shape .     rem 갖추겠다고 적었는데
  w u8 .
  h u8 .
end

rem `rect.area` 를 만들지 않았다

module ex_trait_many .

rem 서명마다 한 줄 — 이름으로 시작하고 입력 · 출력 · 효과 차례다.
trait shape do
  area input s self . output u64 .
  perimeter input s self . output u64 .
  grow input s self . input k u64 . output self .
  checked_area input s self . output u64 . effects panic .
end

struct rect do
  satisfies shape .
  w u64 .
  h u64 .
end

rem 효과 줄이 없는 서명은 `fn` 으로 갖춘다.
fn rect.area input s rect . output u64 .
do
  return mul (field s w) (field s h) .
end

fn rect.perimeter input s rect . output u64 .
do
  return mul 2 (add (field s w) (field s h)) .
end

fn rect.grow input s rect . input k u64 . output rect .
do
  return make rect do w (add (field s w) k) . h (add (field s h) k) . end .
end

rem 효과를 적은 서명은 그 효과를 적은 `proc` 으로 갖춘다.
proc rect.checked_area input s rect . output u64 . effects panic .
do
  if eq (field s w) 0 . do panic "empty rect" . end
  return mul (field s w) (field s h) .
end

module ex_trait_proc_noeff .

trait shape do
  area input s self . output u64 .
end

struct rect do
  satisfies shape .
  w u64 .
  h u64 .
end

proc rect.area input s rect . output u64 .
do
  return mul (field s w) (field s h) .
end

6.11.3 붙은 op 을 부른다 — method

1 method 는 값에 붙은 op 을 부르는 폼이다. 모양은 method <값> <마디> … <이름> <인자> … . 이다.

2 마디와 이름은 타입을 따라가서 갈린다. 수신자의 타입에서 마디를 하나씩 내려가다가, 그 타입에 그 이름의 붙은 op 이 있으면 거기가 이름이고 그 뒤는 전부 인자다. 그러므로 method o inner area 는 o 의 inner 에 붙은 area 를 부르고, method s plus 5 는 s 에 붙은 plus 를 5 로 부른다.

3 수신자는 이름일 필요가 없다. 다른 폼의 결과여도 되며, 그때 수신자의 타입은 그 폼의 출력 타입이다 — 그래서 method (method x grow 2) area 가 성립한다.

4 수신자의 타입을 정할 수 없으면 처리기는 프로그램을 거절한다. 붙은 op 은 타입으로 찾는 것이므로, 타입을 모르면 부를 op 도 정해지지 않는다.

module ex_method .

struct rect do
  w u64 .
  h u64 .
end

fn rect.area input s rect . output u64 .
do
  return mul (field s w) (field s h) .
end

export fn twice_area input s rect . output u64 .
do
  return mul 2 (method s area) .
end

6.11.4 붙은 op 이 어긋나는 자리

1 method 는 수신자와 이름을 모두 요구한다(E-METHOD-RECV).

2 수신자의 타입에 그 이름의 붙은 op 이 없으면 거부된다(E-METHOD-UNDEF) — fn <타입>.<이름> 으로 선언되어 있어야 한다.

module ex_method_undef .

struct p do
  x u8 .
end

fn f input s p . output u8 .
do
  return method s nosuch .
end

6.12.1 융합은 최적화가 아니라 의미다

1 한 pipe 문은 한 번의 훑기(one pass) 로 실행된다. 스테이지 사이에 중간 모음 (intermediate collection)이 만들어지지 아니한다. 이것은 처리기가 시도해 볼 수 있는 최적화 (optimisation) 가 아니라 이 문의 정의다.

2 그러므로 처리기는 중간 모음을 만들지 아니하여야 한다. 만드는 처리기는 적합하지 아니하다.

6.12.2 필요한 만큼만 읽는다

1 any 는 참을 내는 첫 원소에서, all 은 거짓을 내는 첫 원소에서 훑기를 멈춘다. 멈춘 뒤의 원소는 읽히지 아니하며, 그 원소에 대한 스테이지도 실행되지 아니한다.

2 take n 은 n 개를 지나보낸 뒤 훑기를 멈춘다.

module ex_pipe .

fn over2 input a u8 . output bool . do return gt a 2 . end

fn dbl input a u8 . output u8 . do return (wrap_add a a) . end

rem [1,2,3,4,5] → 2 보다 큰 것만 → 두 배 → out 에 담는다. 중간 배열은 생기지 아니한다.
proc fm input xs slice u8 . input out mut slice u8 . output u64 . effects none . do
  pipe xs do
    filter over2 .
    map dbl .
    collect into out .
  end
  return 0 .
end

6.12.3 `pipe` 밖의 `map`·`filter` — 받는 자리에 써 넣는 내장 연산

1 map 과 filter 는 결과를 첫 인자(받는 자리)에 써 넣는다. 그러므로 그 자리는 고칠 수 있어야 한다(E-MAP-SINK, §8.8).

1a 받는 자리가 차는 것은 §6.12 (2c)와 같다 — 알면 번역이, 모르면 실행이 멈춘다. map 은 원천의 원소 수만큼, filter 는 판정을 지난 원소 수만큼 자리가 있어야 한다.

2 이 두 연산이 다루는 원소는 스칼라여야 한다(E-MAP-ELEM). 묶음과 열거는 원소 하나를 한 번에 쓰는 이 길로는 다루지 아니한다.