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

6.2.1 타입의 갈래§

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

6.2.2 정수 타입§

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

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

3 usize 와 idiff 는 주소 공간의 크기와 첨자를 셀 수 있을 만큼 넓은 정수다. 이 둘은 u64·i64 와 폭이 같더라도 다른 타입이며, 서로 자동으로 바뀌지 아니한다. usize 는 길이와 첨자를, idiff 는 두 위치의 차이를 적는 타입이다.

3-1 usize 와 idiff 의 폭은 같고, 구현이 정한다(구현 정의). 그 폭은 16 비트 이상이며, 그 구현이 갖는 가장 넓은 정수 타입의 폭을 넘지 아니한다. 구현은 그 폭을 문서에 적는다. usize 는 부호가 없고 idiff 는 2 의 보수의 부호 있는 정수이므로, idiff 가 담는 양수는 usize 가 담는 범위의 절반이다.

3-2 usize · idiff 는 다른 어떤 정수 타입과도 섞이지 아니한다. 넓히기의 표(§6.2.5 (4))는 이 둘을 포함하지 아니하며 — u8 에서 usize 로도, usize 에서 u64 로도 자동 변환이 없다. 산술과 비교의 두 피연산자 가운데 하나만 usize(또는 idiff)이면 번역이 거부된다(E-TYPE-NOMINAL). usize 와 idiff 사이도 같다. 수 리터럴은 자리의 타입을 따르므로 이 규칙에 걸리지 아니한다.

3-3 usize · idiff 와 다른 정수 타입 사이의 변환은 cast 로 적는다(§6.2.16 (2)). cast 는 값이 목표 타입에 들어가면 그 값을 내고, 들어가지 않으면 트랩한다. widen 과 narrow 는 원천이나 목표가 usize · idiff 이면 번역이 거부된다 (E-TYPE-NOMINAL) — 그 변환이 넓히는지 좁히는지가 구현의 폭에 달려 있어, 방향을 말하는 낱말로는 어느 구현에서나 참인 글을 적을 수 없기 때문이다. 들어가지 않을 때의 처분을 이름이 고르는 narrow_try · narrow_sat · narrow_wrap 은 usize · idiff 를 목표로 받는다.

3-4 리터럴이 그 구현의 usize(또는 idiff)에 들어가지 않으면 번역이 거부된다(E-TYPE-WIDTH). 이것은 정수 변환에서 같은 글의 판정이 구현에 따라 달라지는 유일한 자리다 — 그 값은 그 구현의 주소 공간에 없는 크기이므로, 실행 중의 트랩보다 이르게 거절한다. 대상이 갖지 못한 것을 쓴 글의 거절(§5.6 (4) · (4-2) — 힙 · 부동소수점 · 128 비트 정수 · 원자 폭)은 이 문장 밖이다.

module ex_usize .

fn bucket input xs slice u8 . input h u64 . output u8 .
  requires gt len xs. . 0 . .
do
  let slot u64 mod h. cast u64 len xs. . . . .
  return idx xs. cast usize slot. . . .
end .

fn checked input want u64 . output usize . do
  let p option usize narrow_try usize want. . .
  guard is_some p. . else return 0 . .
  return some_value p. . .
end .

module ex_usize_mix .

fn end_of input start usize . input more u64 . output u64 . do
  return add start. more. . .
end .

module ex_usize_widen .

fn as_u64 input n usize . output u64 . do
  return widen u64 n. . .
end .

3b u128 · i128 은 폭 128 의 정수다. 이 둘은 128 비트 정수를 가진 구현의 대상에서만 선다 — 그렇지 않은 대상에서 이 낱말을 쓰면 번역이 거부된다(E-INT128-TARGET). 구현은 이 둘이 서는 대상을 문서에 적는다.

3b-1 다른 폭의 정수에서 128 비트 자리로는 자동 넓히기가 없다 — widen u128 … · widen i128 … 으로 적는다(E-TYPE-WIDTH). 산술 · 비교 · 비트 연산의 두 피연산자는 둘 다 128 비트이거나 둘 다 아니다. 수 리터럴은 자리의 타입을 따른다 — 64 비트를 넘는 리터럴은 128 비트 자리에만 들어가고, 다른 자리에 오면 번역이 거부된다(E-LIT-RANGE, §6.1).

3b-2 128 비트 정수는 스칼라 자리(지역 · 입력 · 결과 · option · result 의 알맹이)에 더해 구조체의 칸과 슬라이스 · 배열 · 뷰 · 스택의 원소에 선다. 그 바이트 배치는 대상의 C 컴파일러가 128 비트 정수에 주는 것과 같다 — 크기 16 바이트, 정렬 16 바이트, 작은 끝이 먼저(big 을 적은 칸은 뒤집는다). 벡터(vec · matrix)의 원소와 extern 의 경계에 두면 번역이 거부된다 (E-INT128-PLACE) — 128 비트 정수 레인을 가진 벡터 장치가 없고, C 경계의 ABI 는 아직 열지 아니하였다.

3b-3 명령줄로 받는 128 비트 입력은 적은 십진수 그대로다. 그 타입의 범위를 벗어나는 수(u128 의 음수 · 2¹²⁸ 이상, i128 의 ±2¹²⁷ 밖)는 잘라 넣지 않고 거부된다 — 진입 경계의 타입 범위 검사와 같다.

module ex_u128 .

fn wide_mul input a u64 . input b u64 . output u128 . do
  let x u128 widen u128 a. . .
  let y u128 widen u128 b. . .
  return mul x. y. . .
end .

fn top_half input a u64 . input b u64 . output u64 . do
  return cast u64 shr wide_mul a. b. . 64 . . .
end .

module ex_u128_field .

struct acc do
  lo u64 .
  big u128 .
end .

fn acc_bytes output usize . do
  return size_of acc . .
end .

module ex_u128_extern .

export extern fn take input a u128 . output u64 . do
  return 0 .
end .

3a usize 는 포인터를 담는 타입이 아니다. 그 폭은 주소의 폭을 따르지만, 포인터 값은 주소보다 클 수 있고(§5.3 (4a)) 정수에서 되살릴 수 없다. 크기 · 길이 · 첨자에는 usize 를 쓰고, 가리키는 것은 슬라이스와 참조로 적는다.

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 로 계산하며, 처리기가 몰래 더 넓은 정밀도로 계산하지 아니한다.

2a 셈 하나는 반올림 한 번이다. 처리기는 두 셈을 반올림 한 번으로 합치지 아니한다 — 곱하고 더하기(add mul a. b. . c.)를 곱셈 · 덧셈 하나의 명령(FMA)으로 바꾸지 아니한다. 반올림은 «가장 가까운 값, 비기면 짝수» 하나이고, 프로그램이 바꿀 수 없다. C 로 낸 코드도 이 약속을 소스에 담는다 — 그 코드를 짓는 C 컴파일러가 스스로 합치지 않도록 지시를 적는다.

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

4 셈의 결과가 NaN 이면 그것이 NaN 이라는 것은 정해져 있다. 그 NaN 의 부호 비트와 나머지 비트는 자유 선택 (free choice) 이다(FC-0004).

6.2.5 타입 사이의 변환§

1 로우엔트에는 값을 잃는 암묵적 변환이 없다. 좁아지는 자리는 언제나 소스에 적혀 있다. 처리기가 스스로 하는 변환은 아래의 넓히기뿐이고, 그 밖의 변환을 적는 낱말은 cast 다(§6.2.16).

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

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

2b 128 비트 정수(u128 · i128)로의 넓히기는 자동이 아니다 — 반드시 widen 으로 적는다(§6.2.2 (3b-1)).

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

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

 u8 ──▶ u16 ──▶ u32 ──▶ u64          f32 ──▶ f64
   ╲       ╲       ╲
    ▼       ▼       ▼
 i8 ──▶ i16 ──▶ i32 ──▶ i64
 같은 폭으로 내려가는 화살(u8 → i8)도, i 줄에서 u 줄로 가는 화살도 없다
 usize · idiff 는 이 그림에 없다 — 어느 쪽으로도 화살이 없고, 건너는 낱말은 cast 다

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

6.2.6 줄 — 배열과 슬라이스§

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

1a 길이 n 을 먼저 정수 리터럴로, 원소 타입을 뒤에 적는다 — vec n t · matrix k d… t 와 같은 차례다. 원소 타입이 맨 뒤에 오므로 타입이 제 끝을 스스로 안다. 반대로 적으면(array t n — 길이 자리에 타입) 거부된다(E-TYPE-ORDER. lowentc --fmt 가 새 차례로 옮긴다). 길이가 리터럴이 아니면 거부된다(E-TYPE-ARRAY).

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

1c op 은 배열을 돌려줄 수 있다 — output array n t . 또는 이름을 붙여 output r array n t .(§6.4.1 (3e)). 배열에는 값으로 돌려주는 길이 없으므로 부르는 쪽이 자리를 준다:

• 부르는 쪽은 결과를 이름에 묶는다 — var x array n t f a … .(let 도 같다). 그 이름의 틀 안 바이트가 결과의 자리이고,

부름 받는 쪽은 거기에 바로 짓는다(베끼지 않는다).

• 같은 배열을 돌려주는 op 안에서 return g … . 은 자기 자리를 그대로 넘긴다. 다만 g 에 건네는 인자가 그 자리와 같은 바이트를

볼 수 있으면(이름 붙은 결과 자신이거나, 그것에서 나온 이름 — 초기식이나 set 의 오른쪽이 그것을 언급한 지역) 처리기는 임시 자리에 받아 한 번 베낀다 — g 가 쓰는 동안 읽는 쪽이 새 값을 보지 않으므로 답은 겹치지 않을 때와 같다. 겹치지 않는다고 보일 때(인자가 그런 이름을 하나도 언급하지 않을 때)만 바로 넘긴다. 블록 밖의 return(guard … else return …)은 문장을 끼울 자리가 없어 이 규칙이 서지 않는다 — 아래의 E-RESULT-PLACE 가 그대로다.

• 그 밖의 자리(식의 한가운데 · 다른 부름의 인자 · copy 의 원천)에서 배열을 돌려주는 op 을 부르면 자리가 없으므로

번역이 거부된다(E-RESULT-PLACE). 먼저 이름에 묶는다.

• 이름 붙은 결과는 0 에서 시작한다(칸마다 0). 이름 없는 결과의 return v. . 는 v 를 자리에 베껴 돌려준다. 이것은 블록 안의

return 이어야 한다 — guard … else return v. . . 처럼 블록 밖이면 거부된다(E-RESULT-PLACE). 그런 op 은 결과에 이름을 붙인다.

• 원소는 수 타입이고 길이는 정수 리터럴이다(그 밖은 E-TYPE-ARRAY).

1d 배열 안의 배열 — 원소 타입이 다시 배열이어도 된다. array n array m t 는 길이 m 인 줄 n 개가 줄 우선으로 빈틈 없이 놓인 줄이다(C 의 t a[n][m] 과 같은 배치). 원소 타입이 맨 뒤에 오므로 괄호가 들지 않는다((1a)).

• idx a. i. . 는 줄 i 의 바이트를 보는 slice t(길이 m, 복사 없음)다 — (9a) 의 줄의 나열과 같은 규칙을 따른다. 바깥이

mut 이면 그 줄의 칸도 쓸 수 있고, 한 줄을 통째로 바꾸는 set idx a. i. . <줄> . 은 없다(E-TYPE-SET).

• op 의 입력 input x array n array m t . 은 줄의 슬라이스 slice array m t 를 받으며 줄 수가 n 인지 진입에서 검사된다((1b)).

줄의 나열도, 바이트 위의 줄 보기(§8.7 (7a))도 그대로 넘길 수 있다.

• 구조체의 칸이면 원소 n × m 개의 바이트를 레코드 안에 가진다(§6.2.7 (1a) 의 배열 칸과 같다 — 구조체를 베끼면 함께 베껴진다).
• 값은 lit array n array m t <줄>… [_] . 로 짓는다. 줄마다 lit array m t … 이고, 끝의 _ 는 남은 줄을 0 으로 채운다((6a)).
• 원소는 크기 있는 수와 bool 이다. 겹의 수에는 한도가 없다 — array 2 array 3 array 4 u8 은 길이 4 인 줄 3 개짜리 판 2 개(C 의

u8 a[2][3][4])이고, idx a. i. . 는 판 i 를 보는 줄의 슬라이스 slice array 4 u8 이다. 겹마다 idx 가 한 겹씩 벗긴다. 줄의 나열 · 줄 보기의 줄도 배열 안의 배열일 수 있다(slice array 3 array 4 u8 · view_array array 3 array 4 u8 b.).

• 겹의 깊이는 타입의 일부다 — 깊이가 다른 줄의 슬라이스를 넘기거나 묶으면 거부된다(E-TYPE-ARG · E-TYPE-LET). 줄의 슬라이스는

원소의 슬라이스 자리에도 들지 않는다(idx 가 수 대신 줄을 낸다).

• op 은 배열 안의 배열도 돌려줄 수 있다 — output r array n array m t .. (1c) 와 같이 부르는 쪽이 자리를 주고(var x array n array m t f … .),

이름 붙은 결과는 0 인 줄들로 시작한다.

module ex_nested_array .

fn rowsum input g array 2 array 3 u8 . input r usize . output u64 .
  requires lt r. 2 . .
do
  var s u64 0 .
  for x idx g. r. . do
    set s. add s. widen u64 x. . . .
  end .
  return s. .
end .

export fn table output u64 . do
  var g lit array 2 array 3 u8 lit array 3 u8 1 2 3 . _ . .
  set idx idx g. 1 . 2 . 7 .
  return add mul rowsum g. 0 . 100 . rowsum g. 1 . . .
end .

module ex_nested_three .

export fn f output usize . do
  var g lit array 2 array 3 array 4 u8 _ . .
  set idx idx idx g. 1 . 2 . 3 . 9 .
  let plane slice array 4 u8 idx g. 1 . .
  return add len plane. . cast usize idx idx plane. 2 . 3 . . . .
end .

module ex_nested_depth .

fn rows input g array 3 array 4 u8 . output usize . do
  return len g. . .
end .

export fn f output usize . do
  let c lit array 2 array 3 array 4 u8 _ . .
  return rows c. . .
end .

module ex_array_result .

fn squares input n u64 . output r array 3 u64 .
  requires le n. 1000 . .
do
  repeat i usize 3 do
    let v u64 add n. cast u64 i. . . .
    set idx r. i. . mul v. v. . .
  end .
  return r. .
end .

export fn total input n u64 . output u64 .
  requires le n. 1000 . .
do
  let s array 3 u64 squares n. . .
  return add add idx s. 0 . idx s. 1 . . idx s. 2 . . .
end .

module ex_array_result_expr .

fn squares input n u64 . output r array 3 u64 .
  requires le n. 1000 . .
do
  return r. .
end .

export fn first input n u64 . output u64 .
  requires le n. 1000 . .
do
  return idx squares n. . 0 . .
end .

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

3 슬라이스의 길이는 len 으로 읽는다. len s. . 는 s 의 원소 개수이고, 그 타입은 usize 다(§6.2 (3a)). bitset_count · stack_count 와 capacity 가 내는 수도 usize 다. 권한 cap args 에 쓴 len 은 받은 인자의 수다.

3′ 첨자와 경계(idx 의 i, subslice 의 시작과 끝, 원자 연산의 첨자, alloc_bytes 의 capacity)는 usize 다. 다른 정수 타입의 값을 그 자리에 대면 번역이 거부된다(E-TYPE-NOMINAL). 정수 리터럴은 그대로 적는다. 길이가 아닌 수와 만날 때는 변환을 적는다 — cast u64 n. . 는 usize 를 u64 로, cast usize x. . 는 u64 를 usize 로 옮기며, 어느 쪽이든 들어가지 않으면 트랩한다(§6.2 (3-3)).

3″ 원소에 쓰는 값은 그 슬라이스의 원소 타입이어야 한다 — set idx s. i. . v . 에서 v 가 원소 타입으로 넓혀지지 않으면 번역이 거부된다(E-TYPE-WIDTH · E-TYPE-SIGN · E-TYPE-NOMINAL). slice usize 와 slice u64 는 원소의 폭이 같은 구현에서도 다른 타입이다(E-TYPE-NOMINAL) — 위치만 담는 표는 slice usize 로 선언하고, 여러 뜻의 수를 함께 담는 표는 고정 폭으로 두고 읽고 쓰는 자리에 cast 를 적는다.

3‴ usize 는 조각 하나의 것을 센다: 그 길이 · 그 안의 첨자 · 한 번의 연산이 그 조각에서 읽거나 쓰거나 처리한 수. 그런 수는 그 조각의 길이를 넘지 못하므로 어느 구현에서도 usize 에 들어간다. 여러 번에 걸쳐 쌓이는 누계와 기억 장소 밖의 크기 · 위치 (파일의 크기와 위치 · 흐름으로 지나간 바이트의 합 · 메시지 전체의 비트 길이)는 주소 폭과 무관하게 클 수 있으므로 usize 가 아니다 — 고정 폭 정수(u64)로 둔다. 해시 값 · 검사값 · 난수는 길이가 아니다: 그 값의 폭으로 둔다.

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

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

 memory   [ 10 ][ 20 ][ 30 ][ 40 ][ 50 ]
                  ^
 s = { start ─────┘ , len 3 }
 idx s 0 = 20 · idx s 2 = 40 · idx s 3 → trap (len s = 3)

module ex_slice .

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

module ex_array_order .

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

6 원소 나열 리터럴 — lit array n t v₁ … vₖ . 은 array n t 값, lit slice t v₁ … vₖ . 은 원소 k 개의 slice t 값이다. 나열은 제 마침표로 닫히는 폼이다: 문장의 끝에 오면 나열의 점과 문장의 점이 잇달아 오고(let t lit array 4 u8 1 2 3 4 . .), 한가운데 오면 점 하나로 닫고 다음 피연산자가 이어진다. lit 가 값의 타입을 보이므로 묶는 문장은 타입을 따로 적지 않는다.

6a 배열의 원소 수는 n 과 같아야 한다. 모자라면 나열의 끝에 _ 를 적어 «나머지 칸은 0» 이라고 말해야 하며, 넘치거나 _ 가 끝이 아닌 자리에 있거나 슬라이스 나열에 _ 가 있으면 거부된다(E-LIT-COUNT). 칸은 말없이 채워지지 않는다.

6b 각 원소는 t 에 들어가야 한다 — 부호 없는 t 에 음수도 들어가지 않는다(E-TYPE-WIDTH). bool 원소는 true·false 만이다.

6c 칸 골라 채우기 — lit array n t do <번호> <값> . … [_ <값> .] end . 은 번호를 적은 칸에 그 값을 넣는다. 번호는 0 부터 n − 1 까지의 정수 리터럴이고 한 번씩만 적는다. _ <값> . 은 끝에만 오며 «이름을 적지 않은 칸 모두» 를 뜻한다. 모든 칸이 정해져야 한다 — 남는 칸이 있는데 _ <값> . 이 없거나, _ 가 채울 칸이 없으면 거부된다 (E-LIT-COUNT). 번호가 상수가 아니거나 길이 밖이거나 두 번 나오거나 _ 가 끝이 아닌 자리에 있으면 거부된다 (E-LIT-INDEX). 값은 식이어도 되며 적은 차례로 계산되고, _ 의 값은 한 번 계산된다. 블록으로 적은 나열도 폼이라 제 점으로 닫힌다 — let t lit array 8 u8 do 2 5 . _ 0 . end . . 에서 첫 점은 나열을, 둘째 점은 let 을 닫는다. 원소를 늘어놓는 모양과 섞지 않는다

6d SIMD 값 — lit vec n t v₁ … [_] . 은 vec n t 값이다. 원소 규칙은 배열 나열과 같고, 더해 t 는 크기 있는 수(bool 이 아니다), n 은 1 부터 16 까지의 2 의 거듭제곱이다(E-LIT-COUNT). 값의 타입은 묶는 자리의 vec 타입과 레인 수·원소 종류·폭이 모두 같아야 한다(E-TYPE-LANES · E-TYPE-WIDTH). 레인에 값을 싣는 것으로 끝나므로 (7) 의 자리 규칙과 상관없다.

7 나열이 어디에 놓이고 얼마나 사는지는 처리기가 번역 시점에 셋 중 하나로 정한다. 저자는 고르지 않는다. ⓐ var 에 묶은 나열과, 실행 중에 계산되는 원소가 든 let 나열은 그 op 의 틀 안에 선언 자리마다 한 칸을 갖는다. 그 칸은 선언이 실행될 때마다 새로 채워지고(적지 않은 칸은 0), 선언이 든 블록이 끝날 때까지 산다 — 반복 안의 선언은 바퀴마다 다시 채워지고, 재귀한 부름은 저마다 제 칸을 갖는다. ⓑ 원소가 모두 번역 시점 상수이고 let 에 묶였거나 받는 자리 없이 읽기로만 쓰인 나열은 프로그램에 박힌 읽기 전용 바이트다. 프로그램 끝까지 살므로 어디에 담아도 된다. 그것을 mut 인 이름에 묶거나(set 으로 다시 담는 것도 같다) let 에 묶은 그 이름을 mut·owned·mut_ref 자리에 넘기면 거부된다(E-TYPE-ARGMUT). 내용이 같은 두 나열(문자열 리터럴도 같다)이 같은 자리인지는 자유 선택 (free choice) 이다(§4.3 · FC-0003) — 처리기가 한 벌로 합칠 수도, 따로 둘 수도 있다. 그러니 두 쪽이 모두 이런 리터럴에서 왔다는 것이 번역 시점에 보이는 same_slice 는 거부된다(E-LIT-IDENTITY — 리터럴 자신 · 그것에 let 으로 묶은 이름 · 그것의 subslice). 부름을 건너 보이지 않는 경우는 거부되지 않지만, 그 답에 기대는 프로그램은 적합하지 아니하다. ⓒ 받는 이름 없이 쓰인 나열 가운데 실행 중 원소가 들었거나 mut·owned·mut_ref 자리에 곧바로 넘긴 것은 그 문장이 끝날 때까지 사는 틀 안 임시다. 받는 op 은 그 칸을 고쳐 써도 된다.

7a ⓐ·ⓒ 의 칸을 보는 값이 그 수명보다 오래 가는 자리 — return, 선언 블록보다 바깥에 선언된 이름(매개변수와 그 칸·원소를 포함한다), 선언 블록보다 바깥에 선언된 actor 에게 보내는 메시지 — 에 담기면 거부된다(E-LIT-ESCAPE). 같은 블록이나 더 안쪽에 선언된 actor 에게는 건넬 수 있고, 그 뒤로 그 actor 가 주는 값도 같은 수명을 받는다. ⓒ 임시를 이름에 담는 것도 거부된다 — 나열을 var 에 묶어 ⓐ 로 쓴다. 흐름은 부름을 건너 따라간다: 부름의 결과는 그 op 몸에서 결과로 흘러드는 입력의 것만 들고, 스칼라를 돌려주는 부름은 아무것도 들고 나가지 않는다(§8 영역 탈출과 같은 가름이다).

7a-1 이름 없는 구조체 값(부름의 결과 · lit)은 그 문장 끝에 끝난다. 그 값의 배열 칸을 보는 값을 이름 · return · 바깥 자리에 담으면 거부된다(E-VIEW-TEMP) — 문장이 끝나면 그 바이트는 다음에 만든 값의 것이다. 그 자리에서 읽기만 하는 것(len · idx 로 수를 꺼내는 것)은 적합하다. 칸을 오래 보려면 구조체를 먼저 이름에 묶는다(let b T … . 뒤 field b. <칸> .).

7b var 에 묶은 나열은 쓸 수 있는 슬라이스다 — 칸은 set idx buf. i. . v. . 로 쓴다. 그 이름을 다른 저장소로 다시 묶는 set buf … 은 거부된다(E-ARRAY-SET). 각 원소는 (6b) 의 폭 규칙을 따르고, 실행 중 원소는 원소 타입과 맞아야 한다(E-TYPE-SET · E-TYPE-WIDTH). idx 와 subslice 를 거쳐 닿은 칸도 같은 저장소다 — set idx subslice buf. a. b. . i. . v. . 에서 buf 가 쓸 수 있는 이름이 아니면 거부된다(E-TYPE-MUT). 쓸 수 없는 슬라이스를 mut slice 이름에 다시 묶지 못한다 — let w mut slice u32 g. . 와 let w mut slice u32 subslice g. a. b. . . 는 g 가 쓸 수 있는 이름이 아니면 거부된다(E-TYPE-MUT) — mut slice 인 var 에 set w. g. . 로 다시 담는 것도 같다. 새 이름은 같은 저장소를 가리키므로, 그것으로 쓰는 것은 g 에 쓰는 것이다. 뷰 view_array <타입> g. 도 베끼지 않으므로 같다 — 그것을 mut 이름에 묶거나, mut 입력에 넘기거나, 그것을 거쳐 set · copy · store 하면 g 가 쓸 수 있는 이름이어야 한다(E-TYPE-MUT · E-TYPE-ARGMUT). copy 와 store 의 받는 쪽이 subslice 일 때도 그렇다. mut 없는 슬라이스(또는 뷰) 타입의 var 는 다른 슬라이스로 다시 묶을 수 있지만 칸을 쓰는 이름이 아니다 — 그 이름으로 칸에 쓰면 E-TYPE-MUT 이고, mut·owned 입력에 넘기면 E-TYPE-ARGMUT 이다(무엇을 담았든 — 읽기 입력도 문자열 리터럴도).

7b-1 내용 복사 — copy <받는 쪽> <주는 쪽> . 는 주는 쪽 슬라이스의 내용을 받는 쪽에 베낀다. 받는 쪽은 쓸 수 있어야 하고(E-TYPE-MUT), 두 원소 타입이 같아야 하며(E-TYPE-SET), 두 길이가 같아야 한다 — 번역 시점에 다르다고 알면 거부되고(E-COPY-LEN), 실행 중에 다르면 멈춘다. 같은 줄의 두 조각이 겹쳐도 옳게 베낀다(앞뒤가 겹치는 이동과 같다). 받는 쪽에 쓰는 것이므로 매개변수에 베끼는 fn 은 순수하지 않다(E-EFFECT-PURITY).

7b-2 맞바꾸기 — swap <슬라이스> <i> <j> . 는 두 칸의 값을 맞바꾼다. 칸에 쓰는 것이므로 그 슬라이스는 쓸 수 있어야 한다 (E-TYPE-MUT — let 나열 · 문자열 · mut 아닌 매개변수 · 번역 때 지은 배열은 쓸 수 없다).

7c 한 op 의 ⓐ·ⓒ 칸을 모두 더한 크기에는 처리기가 밝히는 한도가 있고, 넘으면 거부된다(E-FRAME-SIZE — 조용히 힙으로 옮기지 않는다). 이 처리기의 한도는 운영체제가 있는 기계 65,536 바이트 · 운영체제가 없는 기계 4,096 바이트다. 그런 칸을 가진 op 이 자기 자신에게 (다른 op 을 거쳐서라도) 닿을 수 있으면 거부된다(E-FRAME-RECURSIVE) — 재귀 깊이만큼 틀이 곱해지는데 그 깊이는 번역 시점에 모르므로, 스택이 모자라지 않음을 보일 수 없다. 재귀 안의 나열은 할당기에서 받는다((7d)). 부르는 관계를 따라 가장 깊은 길에서 동시에 살아 있는 ⓐ·ⓒ 칸의 합이 아래 예산을 넘으면 번역이 거부된다(E-STACK-BUDGET) — 진입(아무도 부르지 않는 op)마다 잰다. 태스크로 도는 op(spawn <op> · spawn send 의 처리기)은 그린스레드 예산으로 따로 잰다. 실행 중에는 한 호출 사슬 위에 동시에 살아 있는 ⓐ·ⓒ 칸과 (7c-1) 의 구조체 칸의 합에도 처리기가 밝히는 예산이 있어, 넘치게 할 op 에는 들어가지 않고 멈춘다 — 스택이 넘쳐 조용히 망가지지 않는다. 이 처리기의 예산은 운영체제가 있는 기계 4 MiB · 그린스레드 64 KiB · 운영체제가 없는 기계 16 KiB 이고, 모든 뒤끝이 같은 수로 세어 같은 자리에서 멈춘다.

7c-1 구조체 값의 자리는 그 op 의 틀이다. 처리기는 op 마다 구조체 값 lit 과 구조체를 돌려받는 부름이 쓸 틀 칸의 수를 번역 때 정한다 — 칸이 모자라는 자리의 값은 §8.1 (3a) 의 풀에 산다. 칸의 몫(칸마다 8 바이트 · 배열 칸은 그 바이트)은 (7c) 의 예산에 든다. 틀이 끝나면 그 값도 끝나고, 돌려주는 값은 부른 쪽의 자리로 베껴진다. 틀 칸에는 재귀가 거부되지 않는다 — 깊이만큼 틀이 쌓이고, 실행 중 (7c) 의 예산이 멈춘다. 재귀하지 않는 길에서 구조체 값이 가장 깊은 길을 예산 너머로 밀면 번역이 거부된다 (E-STACK-BUDGET). 참조를 받거나 만드는 op 은 남의 자리에 쓸 수 있으므로 틀 칸을 쓰지 않는다(그 값은 풀에 산다).

7d 할당기에서 받는 나열 — var <이름> use <할당기> mut slice t lit array n t … else <문장>(lit slice 도 같다)은 그 할당기에 나열의 바이트 수를 청하고(send <할당기> reserve <바이트>), 받으면 그 바이트를 (6) (6c) 대로 채워 이름에 묶고, 못 받으면 else 로 간다(§6.5.1 (5)). 실패를 option 째 들고 가려면 타입을 통째로 적는다 — let <이름> use <할당기> option mut slice t lit … .. else 도 option 도 없거나, lit vec 이면 거부된다 (E-LIT-USING). 바인딩 타입의 원소가 나열의 원소 타입과 다르면 거부된다(E-BIND-ELSE). 바이트는 할당기의 것이라 (7e) 가 아니면 (7a) 의 선언 블록 수명을 받지 않고 할당기의 수명을 따른다: 할당기가 ⓐ 칸을 뒤받침으로 받았다면 (send <할당기> init buf) 그 할당기가 주는 바이트도 그 칸의 수명을 받는다. 구조체 값도 같은 철자로 할당기 바이트에 짓는다: var <이름> use <할당기>. s lit s do … end . else <문장> . 은 size_of s . 바이트를 청해, 받으면 0 으로 채우고 s 의 배치를 얹은 뒤(§8.7.2 의 view 와 같은 표현) 적은 칸을 쓴다. 바인딩 타입은 s 여야 한다(E-BIND-ELSE). 수의 슬라이스 칸은 할당기 바이트 안에 (주소, 길이) 두 낱말로 놓인다 — C 의 struct { const T *p; size_t n; } 와 같고, 자리는 8 바이트에 맞춘다. 이 배치는 할당기에 짓는 구조체에만 있다: 그런 구조체를 남의 바이트에 view 로 얹거나 size_of 로 크기를 묻는 것은 여전히 거부된다(바이트가 주소가 되면 안 된다). 슬라이스 칸에 준 값이 틀 안 자리를 보면 그 구조체도 그 자리의 수명을 받는다 — keep 으로 남겨도 그 자리보다 오래 나르면 거부된다(E-LIT-ESCAPE). owned · actor · 능력 칸, 원소가 수가 아닌 슬라이스 칸, 배치가 없는 안쪽 구조체를 가진 구조체는 짓지 않는다(E-LIT-UNBUILT) — 그 바이트는 칸과 함께 끝을 맺어야 하기 때문이다.

7e 블록 끝에 돌려준다 — 할당기가 freeing_allocator 를 갖추면(§8.13 (6)), (7d) 로 받은 바이트는 그 이름을 선언한 블록을 나갈 때 할당기에 돌려준다(send <할당기> release <받은 조각>). 블록 끝에 닿을 때 · return · 그 블록 안의 break·continue 모두 그렇다. 한 블록에서 여럿을 받았으면 선언의 거꾸로 돌려주고, 받지 못한 것(else 로 간 것)은 돌려줄 것이 없다. release 의 답은 쓰지 않는다 — 돌려받을지는 할당기의 정책이다. 그래서 이 바이트는 (7a) 의 선언 블록 수명을 받는다: 블록 밖으로 나르면 거부된다(E-LIT-ESCAPE). freeing_allocator 가 아닌 할당기의 바이트는 할당기에 남는다. panic 으로 멈출 때는 돌려주지 않는다 — 멈춤은 그 op 을 복구 단위에 넘긴다. 저자는 drop <이름> . 으로 더 일찍 돌려줄 수 있다. 그러면 블록 끝에서는 다시 돌려주지 않는다. drop 은 그 이름을 선언한 블록에서만 받고(안쪽 블록이면 E-OWN-JOIN), 그 뒤로 이름을 쓰면 거부된다(E-OWN-MOVED).

7f 남긴다 — var <이름> keep <할당기> … else <문장> 은 (7e) 를 끈다: 블록을 나가도 돌려주지 않으므로 바이트는 할당기의 수명을 따르고(§6.2.6 (7d)), 블록 밖으로 — return 으로도 — 나를 수 있다. 돌려주는 일은 저자가 한다(send <할당기> release <조각>). 아니면 할당기가 끝날 때 한꺼번에 돌아간다. keep <할당기> 는 use <할당기> 의 자리(이름 바로 뒤)에 서고, 나열이나 구조체 리터럴을 받는 바인딩에만 쓴다(E-USING-FORM).

8 let 에 묶은 배열 나열은 그 바이트를 보는 슬라이스다. 길이는 나열이 정한다.

9 나열의 원소는 바이트 배치가 있는 구조체여도 된다(칸이 모두 크기 있는 수 — §8.7.2 의 view 가 설 수 있는 구조체). 원소는 준 값의 사본이고, 나열은 그 바이트 위에 view_array 와 같은 보기를 얹은 slice s 다. 원소의 칸은 set field <나열>. <자리> <칸> . v. . 로 쓴다. 자리 · 수명 · _ · 칸 골라 채우기 · 할당기 절은 수 원소와 같다. 원소 자리의 값이 수이거나 참거짓이면 E-TYPE-FIELD, 다른 구조체이면 E-TYPE-STRUCT 로 거부된다. 이 처리기가 아직 짓지 않은 나열 — 바이트 배치가 없는 구조체 · 칸이 구조체인 구조체 · 줄을 골라 채우기(do … end) — 은 무엇이 아직인지 말하며 거부된다(E-LIT-UNBUILT). 구조체 안의 배열 칸은 §6.2.7 (1a) 가 정한다.

9-1 칸이 크기 있는 수 · bool 과 수의 슬라이스뿐인 구조체도 나열의 원소가 된다. 원소 안에서 슬라이스 칸은 (가리키는 자리, 길이) 두 낱말로 놓인다 — 할당기 바이트에 지은 구조체((7d))와 같은 배치다. 칸은 실행할 때 쓰므로 그런 나열은 ⓐ 의 틀 안 자리에 선다. 같은 원소를 받는 slice s 입력과 배열 결과 output r array n s . 도 이 배치다. 슬라이스 칸은 남의 바이트를 가리킬 뿐이라, 원소를 베껴도 가리키는 바이트는 베끼지 않는다.

9a 줄의 나열 — 원소가 고정 길이 배열 (array m t) 인 나열 lit slice array m t <줄>… . 의 타입은 slice array m t 이다. 다른 슬라이스 나열처럼((6)) 줄의 수를 적지 않고 _ 가 없다((6a)) — 0 인 줄은 lit array m t _ . 로 적는다. 줄 수를 적은 lit array n array m t <줄>… [_] . 는 배열 안의 배열의 값이다((1d)). 이미 있는 바이트 위에는 view_array array m t b. 로 같은 타입의 줄 보기를 얹는다(§8.7 (7a)). len 은 줄 수이고, idx g. r. . 는 줄 r 의 바이트를 보는 slice t(길이 m, 복사 없음)다 — 바깥이 mut 이면 그 줄의 칸도 쓸 수 있다. 줄 값은 칸마다 베껴지고, 줄 리터럴의 모양이 array m t 과 다르면 거부된다(E-LIT-COUNT). 한 줄을 통째로 바꾸는 set idx g. r. . <줄> . 은 없다(E-TYPE-SET) — 칸을 쓰거나 copy 로 베낀다. 틀 안 나열의 줄(과 구조체 원소)은 그 틀의 바이트를 보므로 블록 밖으로 나르면 E-LIT-ESCAPE 다.

module ex_list_literal .

fn total input xs slice u32 . output u64 . do
  var s u64 0 .
  for x xs. do
    set s. add s. widen u64 x. . . .
  end .
  return s. .
end .

rem 배열 나열은 제 점으로 닫힌다 — 문장의 끝이면 점이 둘이다.
export fn f output u64 . do
  let t lit array 4 u32 10 20 30 _ . .
  return add total t. . total lit slice u32 1 2 . . . .
end .

module ex_frame_list .

export fn squares input n usize . output u64 . do
  var buf lit array 8 u64 _ . .
  var i usize 0 .
  while lt i. 8 . do
    set idx buf. i. . cast u64 mul i. i. . . .
    set i. add i. 1 . .
  end .
  guard lt n. 8 . else return 0 . .
  return idx buf. n. . .
end .

module ex_cell_fill .

export fn pick input a u64 . input i usize . output u64 . do
  let t lit array 6 u64 do 0 100 . 5 mul a. 2 . . _ 1 . end . .
  guard lt i. 6 . else return 0 . .
  return idx t. i. . .
end .

module ex_cell_twice .

export fn f output u64 . do
  let t lit array 4 u8 do 1 1 . 1 2 . _ 0 . end . .
  return len t. . .
end .

module ex_frame_escape .

export fn f output slice u8 . do
  var b lit array 2 u8 1 2 . .
  return b. .
end .

module ex_list_short .

export fn f output u64 . do
  let t lit array 4 u8 1 2 3 . .
  return len t. . .
end .

6.2.6.1 여러 차원의 줄 — matrix§

1 matrix k d1 … dk t 는 타입 t 의 값이 d1 × … × dk 개 놓인, 차원이 k 개인 줄이다. 차원 수와 크기는 타입의 일부이며 번역 시점에 정해진다. 차원 수나 크기가 하나라도 다르면 다른 타입이다 — matrix 2 3 4 u32 는 matrix 2 4 3 u32 과도, array 12 u32 와도 다르다.

1a 차원 수를 먼저, 크기를 차원 수만큼 그다음에, 원소 타입을 맨 뒤에 적는다(§6.2.6 (1a) 와 같은 차례). 차원 수는 2 이상 8 이하이고 크기는 1 이상이며, 모두 꾸밈 없는 십진 리터럴이다(op 의 입력에서는 크기가 번역 시점 값 입력의 이름일 수 있다 — (3a)). 옛 차례(matrix t k d… — 원소 타입이 먼저)는 거부된다(E-TYPE-ORDER). 원소 수(크기들의 곱)는 2^32 를 넘지 못한다. 원소 타입에 matrix 나 array 를 적지 못한다. 어기면 거부된다(E-MATRIX-TYPE).

2 배치. 원소는 한 덩어리로 이어 놓으며 줄 우선이다 — 마지막 색인이 가장 빨리 돈다. 크기와 정렬은 array n t(n 은 크기들의 곱)과 같고, 덧붙는 머리는 없다.

3 matrix 타입은 이름을 짓는 자리에 적는다 — let · var 의 타입, op 의 input 과 output, 구조체의 칸. 다른 타입의 원소, 타입 인자, 별칭의 자리에는 적지 못한다(E-MATRIX-USE).

3a op 의 input 에 한하여, 크기 자리에 그 op 의 번역 시점 값 입력의 이름을 적을 수 있다 — input comptime r u64 . input comptime c u64 . input m matrix 2 r c u32 .. 부르는 쪽은 그 입력에 수를 적고 (sum 3 4 a. .), 인자의 모양은 그 수로 읽은 모양과 같아야 한다(E-MATRIX-SHAPE). let · var · output · 구조체의 칸과 lit matrix 의 크기는 수여야 한다(E-MATRIX-TYPE).

4 값. lit matrix k d1 … dk t <원소>… . 는 원소를 줄 우선 차례로 나열한다. 원소 수는 크기들의 곱과 같아야 하며, 모자라면 끝에 _ 를 적어 나머지를 0 으로 채운다. 바인딩에 타입과 리터럴을 함께 적으면 둘의 모양이 같아야 한다. 어기면 거부된다(E-MATRIX-SHAPE). 구조체 리터럴에서 matrix 칸의 값은 그 칸과 같은 모양의 lit matrix 다.

5 읽기와 쓰기. idx m. i1 … ik . 는 색인을 차원마다 하나씩 받는다. 색인 수가 차원 수와 다르면 거부된다 (E-MATRIX-INDEX) — 색인을 덜 준 idx 가 줄을 뜻하지는 아니한다(줄은 (7a) 의 row 다). 색인은 저마다 제 차원의 크기로 검사한다: 어느 하나라도 제 크기 이상이면 실행이 멈춘다. 색인 식은 적힌 차례로 한 번씩 계산한다. set idx m. i1 … ik . v. . 는 그 칸에 쓰며, m 은 쓸 수 있는 이름이어야 한다(E-TYPE-MUT).

6 dim m. j . 는 차원 j 의 크기다(0 부터 센다). j 는 차원 수보다 작은 꾸밈 없는 십진 리터럴이어야 한다 (E-MATRIX-INDEX). 그 값은 번역 시점의 상수다.

7 flat m. . 는 같은 원소를 한 줄로 본 slice t 다. 복사하지 아니하며, 길이는 원소 수다.

7a row m. i1 … i(k−1) . 는 마지막 차원 하나를 남긴 줄이다 — 색인은 마지막을 뺀 차원마다 하나씩이고, 값은 그 줄의 원소를 보는 slice t 다. 복사하지 아니하며 길이는 마지막 차원의 크기다. 색인 수가 다르면 거부되고(E-MATRIX-INDEX), 색인은 (5) 와 같이 저마다 제 차원의 크기로 검사한다. m 이 쓸 수 있는 이름이면 그 줄을 mut slice t 이름에 묶어 쓸 수 있고, 아니면 그렇게 묶지 못한다(E-TYPE-MUT · let 으로 묶은 구조체의 칸이면 E-IMMUTABLE). 남는 차원이 둘 이상인 보기(면)는 없다.

7b (5) · (6) · (7) · (7a) 의 m 자리에는 matrix 로 적힌 이름뿐 아니라 matrix 칸을 가리키는 field x. g . 도 선다 — idx field b. g . r. c. ..

8 len m. . 과 for x m. do … end . 는 거부된다(E-MATRIX-USE). 차원 하나의 크기는 dim 으로, 모든 원소를 도는 것은 for x flat m. . do … end . 로 적는다.

9 matrix 이름을 통째로 적을 수 있는 자리는 idx · row · dim · flat 의 첫 인자, 같은 모양의 입력을 가진 op 의 인자, 같은 모양의 결과를 가진 op 의 return 이다. 그 밖의 자리는 거부된다(E-MATRIX-USE). 인자와 입력, 바인딩의 타입과 부른 op 의 결과는 차원 수와 크기가 모두 같아야 한다(E-MATRIX-SHAPE).

9a 결과가 matrix 인 op 의 호출은 두 자리에만 놓인다 — 같은 모양의 matrix 이름을 짓는 바인딩의 값, 같은 모양의 결과를 가진 op 의 return 의 값. 결과가 matrix 인 op 의 return 은 그 모양의 matrix 이름이나 그 모양을 내는 op 의 호출을 준다. array 이름에 묶거나 array 를 내는 op 에서 돌려주는 것을 포함하여, 어기면 거부된다 (E-MATRIX-SHAPE).

10 이 타입은 자리만 정한다. 행렬의 곱 같은 셈은 정하지 아니한다.

module ex_matrix .

fn table output t matrix 2 3 4 u32 .
do
  repeat r usize dim t. 0 . do
    repeat c usize dim t. 1 . do
      set idx t. r. c. . cast u32 add mul r. 10 . c. . . .
    end .
  end .
  return t. .
end .

export fn row_sum input r usize . output u64 .
  requires lt r. 3 . .
do
  let t matrix 2 3 4 u32 table . .
  var s u64 0 .
  repeat c usize dim t. 1 . do
    set s. add s. widen u64 idx t. r. c. . . . .
  end .
  return s. .
end .

module ex_matrix_more .

struct board do
  id u64 .
  g matrix 2 3 4 u32 .
end .

fn sum input comptime r usize . input comptime c usize . input m matrix 2 r c u32 . output u64 .
do
  var t u64 0 .
  repeat i usize dim m. 0 . do
    for x row m. i. . do set t. add t. widen u64 x. . . . end .
  end .
  return t. .
end .

export fn total output u64 .
do
  var b lit board do id 1 . g lit matrix 2 3 4 u32 1 2 3 4 5 6 7 8 9 10 11 12 . . end . .
  set idx field b. g . 0 0 . 100 .
  let small lit matrix 2 2 2 u32 1 2 3 4 . .
  return add widen u64 idx field b. g . 0 0 . . sum 2 2 small. . . .
end .

module ex_matrix_row .

export fn f output u64 . do
  let m lit matrix 2 2 3 u32 1 2 3 4 5 6 . .
  return widen u64 idx m. 1 . . .
end .

module ex_matrix_shape .

fn first input m matrix 2 3 4 u32 . output u32 . do
  return idx m. 0 0 . .
end .

export fn f output u32 . do
  let m lit matrix 2 4 3 u32 _ . .
  return first m. . .
end .

6.2.7 묶음 — struct 와 enum§

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

1a 배열 칸 — 칸의 타입이 array n t 이면 그 칸은 원소 n 개의 바이트를 레코드 안에 가진다(길이가 타입에 있으므로 자리가 정해진다). t 는 크기 있는 수나 bool 이다 — 구조체나 배열을 원소로 가진 칸은 이 처리기가 아직 짓지 않았다(E-LIT-UNBUILT). 한 구조체의 배열 칸 바이트 합에는 틀과 같은 한도가 있다(E-FRAME-SIZE, §6.2.6 (7c)). field r. body . 는 그 바이트를 보는 슬라이스이고, set idx field r. body . i. . v. . 가 레코드의 원소를 쓴다. 칸에 주는 나열 리터럴은 칸과 원소 타입·길이가 같아야 한다(E-TYPE-FIELD). 바이트 배치(view · encode · size_of · C 쪽 레이아웃)에서 배열 칸은 C 와 같이 구조체 바이트 안에 그대로 놓인다 — 크기는 n × |t|, 정렬은 t 의 것이다 (len u8 . body array 4 u8 . tail u16 . 은 8 바이트 — len 은 0 번째 · body 는 1 번째 · tail 은 6 번째 바이트부터). 뷰의 배열 칸은 그 바이트를 보는 슬라이스이고, 칸에 쓰면 그 자리에 베낀다.

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

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

2b 열거 값은 수가 아니다 — 갈래의 번호를 수로 쓰려면 cast 로 적는다(§6.2.16 (5)).

2c 갈래마다 번호가 있다. 첫 갈래는 1 이고, 다음 갈래는 앞 갈래의 번호에 1 을 더한 것이다. 갈래 이름 뒤에 정수를 적으면 (ga 11 .) 그 갈래의 번호가 되고, 다음 갈래는 거기서 이어 센다. 번호는 선언된 차례대로 올라야 한다 — 앞 갈래의 번호보다 크지 않은 번호는 거부된다(E-ENUM-NUMBER). 번호는 값을 지닌 갈래가 없는 열거에만 적는다(E-ENUM-NUMBER). 0 은 첫 갈래의 번호가 아니다 — 번호를 적지 않은 열거에서 0 은 어느 갈래도 아니다.

module ex_enum_numbers .

enum hangul do
  ga 11 .
  na .
  da 101 .
  ra .
end .

fn n input h hangul . output u32 . do
  return cast u32 h. . .
end .

rem 11 + 12 + 101 + 102
fn total output u32 . do
  return add add n ga. . n na. . . add n da. . n ra. . . . .
end .

total() = 226

module ex_enum_number_falls .

enum level do
  low 5 .
  mid .
  high 6 .
end .

2d 열거의 폭. 갈래에 값을 지니지 않은 열거는 블록 안에 layout <폭> . 한 줄을 둘 수 있다. 폭은 u8 · u16 · u32 · u64 가운데 하나이고, 그 열거가 바이트 배치(§6.2.13)에 들어갈 때 차지하는 바이트 수다 — 바이트에는 갈래의 번호(2c)가 든다. 이 줄은 갈래가 아니다. 폭을 적지 않은 열거에는 바이트 배치가 없다. 다음은 거부된다(E-ENUM-LAYOUT): 넷 밖의 폭, 어느 갈래의 번호가 폭에 들어가지 않는 것, 값을 지닌 갈래가 있는 열거, layout 줄이 둘인 것. ☞ 폭을 저절로 고르지 않는 까닭: 갈래 하나를 더하는 일이 선이나 파일 너머의 배치를 말없이 바꾸면 안 된다.

module ex_enum_layout .

enum kind do
  layout u8 .
  ping .
  data 7 .
  close .
end .

struct hdr do
  layout packed .
  k kind .
  len u16 big .
end .

fn kind_of input b slice u8 . output u8 . do
  let o option view hdr try_view hdr b. . .
  guard is_some o. . else return 0 . .   rem 2 는 어느 갈래의 번호도 아니다
  let h view hdr some_value o. . .
  match field h. k . do
    case ping do return 1 . end .
    case data do return 2 . end .
    case close do return 3 . end .
  end .
end .

kind_of([7,0,3]) = 2 · kind_of([2,0,3]) = 0

module ex_enum_layout_fit .

enum code do
  layout u8 .
  ok .
  far 300 .
end .

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

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

3b 칸의 타입이 꼭 option (owned <그 struct>) 이면 (3) 의 순환으로 보지 아니한다. 그 칸은 값이 아니라 얼로케이터 바이트에 지은 다른 마디를 가리키는 주소 한 칸이고(비어 있으면 none), 그래서 크기가 정해진다. 이런 struct 를 스스로를 품는 마디라 하며, 짓고 돌려주는 규칙은 §8.5 (10)–(13) 이 정한다. option 없는 owned <자기> 와, 다른 struct 를 거쳐 돌아오는 소유 순환은 여전히 (3) 에 걸린다.

module ex_shape .

struct point do
  x u32 .
  y u32 .
end .

enum color do
  red .
  green .
end .

4 struct 값은 lit 로 만든다. 만들 때 모든 칸을 채워야 한다. 마지막 줄의 _ <값> . 은 적지 않은 칸 모두에 그 값을 넣는다(lit pt do y a. . _ 0 . end .) — 값은 이름이나 리터럴 하나이고(E-LIT-INDEX), 그 값이 들어갈 수 없는 칸이 남으면 그 칸 이름을 대며 거부되며(E-TYPE-FIELD), 채울 칸이 없으면 거부된다(E-LIT-COUNT).

4a struct 는 값이다. 만들거나 베낄 때(var q point p. .) 배열 칸의 바이트와, 칸에 든 다른 struct 값까지 함께 베껴진다 — 베낀 쪽을 고쳐도 원본은 바뀌지 아니한다. actor 인스턴스(정체가 있는 것)와 owned 칸을 가진 struct 는 베끼지 않고 같은 것을 가리킨다.

4b 칸에 쓰는 것은 그 레코드에 쓰는 것이다. set field r. x . v. . 와 배열 칸의 원소 쓰기는 r 이 쓸 수 있는 자리일 때만 받는다: var 이거나 mut 매개변수다. let 으로 묶은 레코드에 쓰면 거부된다(E-IMMUTABLE) — 배열 칸을 쓸 수 있는 슬라이스(mut slice)로 꺼내는 것도 같다. 값으로 받은 매개변수의 칸에 쓰면 그 op 의 지역 복사에 쓴다 — 부른 쪽의 레코드는 바뀌지 아니한다(§6.5.1 (2a)).

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

module ex_make .

struct point do
  x u32 .
  y u32 .
end .

export fn origin output point .
do
  return lit 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_struct_array .

struct pkt do
  len u8 .
  body array 4 u8 .
end .

export fn copy_keeps input a u8 . output u64 . do
  var p lit pkt do len 2 . body lit array 4 u8 1 a. _ . . end . .
  var q pkt p. .
  set idx field q. body . 0 . 100 .
  return add widen u64 idx field p. body . 0 . . widen u64 idx field q. body . 0 . . . .
end .

module ex_struct_array_let .

struct pkt do
  body array 4 u8 .
end .

export fn f output u64 . do
  let p lit pkt do body lit array 4 u8 _ . . end . .
  set idx field p. body . 0 . 1 .
  return 0 .
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 꺼내는 연산은 부분 연산이다 — 확인하지 않고 꺼내는 것 자체는 번역이 거부하지 아니하며, 실행 중에 없는 쪽을 꺼내면 트랩한다. 곧 확인은 번역이 대신해 주는 것이 아니라 저자가 하는 것이다.

3b 담긴 값의 타입은 그 타입의 일부다. option usize 와 option u64, result u32 e 와 result u64 e 는 서로 다른 타입이며, 한쪽을 다른 쪽의 자리에 대면 번역이 거부된다(E-TYPE-NOMINAL · E-TYPE-WIDTH · E-TYPE-SIGN). 꺼낸 값 (some_value · ok_value)의 타입은 담긴 값의 타입이다. some · ok 가 리터럴을 감쌀 때는 받는 자리의 타입을 따른다.

3c result · option 의 값은 셈이나 견줌(eq · lt …)의 피연산자가 아니다(E-TYPE-KIND). 무엇을 묻는지 적는다 — is_some · is_ok · value_or.

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(있는 값).

 ok v  | error e  ──▶ is_error r ── false ──▶ ok_value r    = v
                                 └─ true ──▶ error_value r = e
 some v | none    ──▶ is_some o  ── true  ──▶ some_value o  = v
                                 └─ false ─▶ some_value o  → trap

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 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 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 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 <이름> <타입> . 이다. 이름과 타입 사이에 낱말을 끼우지 아니한다.

module ex_newtype_mix .

newtype node_id u64 .

fn f input a node_id . input b u64 . output u64 . do
  return add a. b. . .
end .

2b type 과 newtype 의 타입은 줄 타입 — slice · array · matrix — 그 자체일 수 없다. mut 를 앞에 붙인 것도 같다. 줄 타입은 쓰는 자리에 그대로 적는다. 다른 타입 안에 든 줄 타입은 이름을 붙일 수 있다(type found option slice u8 .). 제 이름을 가진 타입이 필요하면 구조체의 칸으로 둔다(§6.2.7).

module ex_rowname .

type bytes slice u8 .

fn f input b bytes . output u64 . do
  return len b. . .
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.2.6 (1a) 와 같은 차례 — 레인 수가 먼저다. 옛 차례 vec <원소 타입> <레인 수> 는 E-TYPE-ORDER). 레인 수 자리에는 scalable 도 선다(vec scalable u8). 레인 수는 번역 시점에 정해진 값이어야 한다(§6.8).

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

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

3a 레인마다의 산술은 add · sub · mul · div · mod · neg · abs · min · max 이다. 정수 레인의 넘침은 그 레인의 폭으로 감긴다(스칼라와 다르다 — 부호 있는 레인의 가장 작은 값을 −1 로 나눈 몫과 그 neg · abs 는 그 값 자신이다). 정수 레인의 div · mod 에서 나누는 수가 0 인 레인이 있으면 스칼라와 같이 멈춘다. 몫은 0 쪽으로 자르고, mod 는 나누는 수의 부호를 따르며(§6.3), 부호 있는 레인의 min · max 는 부호로 견준다(2026-11-02). 부동소수점 레인에는 mod 가 없다 — 스칼라와 같이 번역이 거부된다(§6.3.3 (2a) · E-TYPE-KIND).

module ex_vec_order .

export fn sum4 input xs slice u32 . output u32 .
  requires ge len xs. . 4 . .
do
  let v vec u32 4 load xs. 0 . .
  return reduce_add v. . .
end .

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

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

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

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

4 원소를 넣는 것은 bitset_insert <집합> <값> ., 지우는 것은 bitset_remove <집합> <값> . 이다 — 둘 다 그 자리에서 집합을 바꾼다. add 는 수의 덧셈만 뜻하므로 집합에 쓰는 것은 적합하지 아니하다(E-BITSET-ADD).

4a 집합에 든 원소의 수는 bitset_count <집합> 이고, 그 타입은 usize 다. 스택의 원소 수는 stack_count <스택> 이다. 둘을 서로 바꿔 쓰거나 조각의 길이인 len 을 집합 · 스택에 쓰면 번역이 거부된다(E-TYPE-ARG).

module ex_bitset .

fn members output usize . do
  var s bitset 8 bitset_new 8 . .
  bitset_insert s. 3 .
  bitset_insert s. 5 .
  bitset_remove s. 3 .
  return bitset_count s. . .
end .

members() = 1

6.2.13 바이트 위에 얹는 눈 — 뷰§

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

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

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

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

5 구조체 위에 얹는 뷰는 창이다. view <구조체> <바이트> 는 바이트 슬라이스 위에 그 구조체의 배치를 얹은 창을 준다. 창의 칸을 읽으면 그 자리의 바이트를 읽고, 칸에 쓰면 그 자리의 바이트에 쓴다 — 베낀 사본이 아니다. 창의 타입은 view T(읽기 창) 또는 mut view T(쓰기 창)이고, 구조체 값의 타입 T 와 다르다. try_view 는 같은 일을 하되 길이 · 정렬이 맞지 않거나 칸이 맞지 않으면(9a) none 을 준다 — 그 타입은 option view T · option mut view T 이고 some_value 는 창이다. 길이와 정렬의 조건은 §8.7.2 가 정한다.

6 창과 값은 섞이지 않는다. 창을 구조체 이름 T · option T 의 자리에 두면 — 묶기 · 돌려주기 · 창 이름에 구조체 값을 통째로 넣기 — 번역이 거부된다(E-VIEW-COPY). 바이트와 따로 사는 사본은 cast T <창> . 으로 짓는다(§6.2.16 — 명시적 변환은 cast 다). 창을 다른 창 이름에 묶으면 같은 바이트를 본다. 값을 받는 입력(input p T .)에는 창도 넘길 수 있다 — 받는 쪽은 읽기만 한다.

7 고칠 수 있음은 타입에 적힌다(§8.8 (2)). 쓰기 창은 쓸 수 있는 바이트에서만 나온다 — 공유 입력, mut 없이 묶은 슬라이스, 문자열 리터럴, 읽기 창, 읽기 창을 내는 op 의 결과에서 쓰기 창을 묶으면 거부된다(E-TYPE-MUT). 읽기 창으로 칸에 쓰거나 write_volatile 하면 E-TYPE-MUT, 읽기 창을 mut 입력에 넘기면 E-TYPE-ARGMUT, 출력이 mut view T 인데 읽기 전용 바이트의 창을 돌려주면 E-TYPE-RETMUT 이다. fn 이 mut 으로 받은 바이트의 창에 쓰면 — 직접 얹은 것이든 다른 op 이 돌려준 것이든 — 부른 쪽에 보이므로 순수하지 않다(E-EFFECT-PURITY, §7.3 (6)).

8 뷰를 얹을 수 있는 구조체는 바이트 배치가 정해진 구조체다. 칸마다 폭이 정해진 수(u8…u64 · i8…i64 · f32 · f64), bool, 폭을 적은 열거(§6.2.7 (2d)), 그런 것들의 고정 배열, 또는 그런 칸으로 된 구조체여야 한다. 폭을 적지 않은 열거 · 슬라이스 · option · 소유 핸들 칸은 정해진 바이트가 없으므로 그 구조체에는 뷰도 encode 도 쓸 수 없다(E-IR-UNDEF).

9 view 와 view_array 로 읽는 구조체의 칸은 모두 plain 이어야 한다(§8.7.1 (2)). bool 칸은 0 · 1 아닌 바이트를 받으면 참도 거짓도 아닌 값이 되고, 열거 칸은 어느 갈래의 것도 아닌 번호를 받으면 어느 갈래도 아닌 값이 되므로, 그런 칸이 (안에 든 구조체까지) 하나라도 있으면 거부된다(E-TYPE-BITCAST) — bit_cast bool 을 거부하는 것과 같은 까닭이다. view_array bool 도 같다. 값을 바이트로 적어 내리는 encode 에는 이 제한이 없다.

9a try_view 는 그런 칸을 잰다 — bool 칸의 바이트가 0 · 1 이 아니거나 열거 칸의 번호가 그 열거의 어느 갈래의 번호도 아니면 none 을 준다. 안에 든 구조체의 칸도 잰다. 그렇게 얻은 값의 열거 칸을 읽으면 그 번호의 갈래가, 열거 칸에 쓰면 그 갈래의 번호가 바이트에 든다. 잰 뒤에 아래 바이트가 다른 길로 바뀌어 어느 갈래의 번호도 아니게 되면 그 칸을 읽는 순간 실행이 멈춘다.

module ex_struct_view .

struct pt do
  x u8 .
  y u8 .
end .

proc write_through input b mut slice u8 . output u8 . effects none . do
  let h mut view pt view pt b. . .
  set field h. y . 9 .     rem b 가 [1,9] 가 된다
  return idx b. 1 . .
end .

proc copy_by_name input b mut slice u8 . output u8 . effects none . do
  let h view pt view pt b. . .
  var k pt cast pt h. . .  rem 구조체 값의 사본
  set field k. y . 7 .
  return idx b. 1 . .      rem b 는 그대로다
end .

write_through([1,2]) = 9 · copy_by_name([1,2]) = 2

module ex_struct_view_ro .

struct pt do
  x u8 .
  y u8 .
end .

proc f input b slice u8 . output u8 . effects none . do
  let h mut view pt view pt b. . .  rem 칸에 쓰면 부른 쪽의 b 가 바뀐다
  set field h. y . 9 .
  return 0 .
end .

module ex_struct_view_copy .

struct pt do
  x u8 .
  y u8 .
end .

fn f input b slice u8 . output u8 . do
  let h pt view pt b. . .  rem 창인가 사본인가 — `view pt` 또는 `cast pt`
  return field h. y . .
end .

module ex_struct_view_bool .

struct flag do
  active bool .
  n u8 .
end .

fn f input b slice u8 . output u8 . do
  let h view flag view flag b. . .
  return field h. n . .
end .

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) — 그 밖의 수는 어떤 기계도 지킬 수 없다.

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

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

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

module ex_layout .

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

fn hdr_kind input b slice u8 . output u64 . do
  let v view wire_header view wire_header b. . .
  return widen u64 field v. kind . . .
end .

6.2.16 명시적 변환 — cast§

1 값을 다른 타입으로 읽는 일은 소스에 적힌 곳에서만 일어난다. 처리기가 스스로 하는 변환은 넓히기(§6.2.5 (2)) 하나이며, 그 밖의 변환은 모두 저자가 낱말로 적는다. 그 낱말의 중심이 cast <타입> <값> 이다 — cast 는 이 언어에서 명시적 변환을 맡는 낱말이다. widen 은 값이 변하지 않는 자리에만 쓰고, 값이 변할 수 있는 변환은 cast 로 적는다 — 부호를 바꾸거나, 갈래를 넘거나, 좁히는 자리다.

1a 변환을 적는 낱말은 셋이며 각자 맡은 자리가 다르다.

1a-1 narrow 가 갈래를 넘으면(정수 ↔ 부동소수점) 번역이 거부되고(E-TYPE-KIND), 대상이 값보다 넓으면 거부된다(E-TYPE-WIDTH — 그 낱말은 widen 이다).

1a-2 narrow f32 는 f64 값을 f32 로 한 번 반올림한다((3-1) 과 같은 반올림이다). 유한한 값이 f32 의 가장 큰 유한값을 넘어 반올림되면 — 그 값이 f32 에 들어가지 않으므로 — 실행이 멈춘다. 무한대와 NaN 은 그대로 넘어간다. 넘친 값을 같은 부호의 무한대로 받으려면 cast f32 를 쓴다.

1b 어느 쪽으로 읽을지 갈릴 수 있는 변환은 저절로 일어나지 아니하며 cast 를 거친다. 같은 비트가 두 가지 수로 읽힐 수 있거나, 대상 기계에 따라 넓히기도 되고 좁히기도 되거나, 값의 갈래가 바뀌는 변환이 그렇다. 이 규칙은 앞으로 언어에 들어오는 타입과 변환에도 적용된다 — 새 변환이 애매하면 그 철자는 cast 이고, 암묵 변환을 늘리는 쪽으로 정하지 아니한다.

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

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

3-1 부동소수점 타입으로 가는 cast 는 — 정수에서든 다른 부동소수점 타입에서든 — 대상 타입에서 가장 가까운 값을 내고, 둘이 똑같이 가까우면 끝자리가 짝수인 쪽을 낸다. 반올림은 한 번이다 — 정수를 f32 로 바꿀 때 f64 를 거쳐 두 번 반올림하지 아니한다. 대상 타입의 가장 큰 유한값을 넘어 반올림되는 값은 같은 부호의 무한대가 되고, NaN 은 NaN 이다. 이 변환은 (2) 의 트랩을 하지 아니한다 — 부동소수점 타입에는 넘친 값이 갈 무한대가 있다. f32 에서 f64 로는 값이 그대로다. cast f32 <f64 1e300> 은 +∞ 이고, cast f32 <u64 16777217> 은 16777216 이다.

3a usize · idiff 와 다른 정수 타입 사이는 cast 로만 건넌다(§6.2 (3-3)). 이 변환은 구현의 폭에 따라 넓히기이기도 좁히기이기도 하므로 cast 가 그 철자다 — 값이 들어가면 그대로 내고, 들어가지 않으면 (2) 대로 트랩한다. 폭이 같거나 넓어지는 구현에서 이 cast 는 검사를 남기지 아니한다.

4 참거짓에서 정수로는 cast 로 간다 — cast <정수 타입> <참거짓> 은 참이면 1, 거짓이면 0 이다. 그 값은 어느 정수 타입에도 들어가므로 (2) 의 트랩은 일어나지 아니한다. 부동소수점 타입은 이 변환의 대상이 아니다(E-TYPE-KIND).

4a 정수에서 참거짓으로 가는 cast 는 없다 — bool 은 cast 의 대상이 될 수 없다(E-TYPE-KIND). 무엇을 묻는지를 적는다: ne n. 0 . 또는 eq n. 0 .. 수의 어느 값이 참인지는 그 물음이 정한다.

4b 참거짓은 widen 의 표(§6.2.5 (4))에 없다 — widen <정수 타입> <참거짓> 은 거부된다(E-WIDEN-KIND). 참거짓을 수로 바꾸는 철자는 cast 하나다.

module ex_bool_cast .

fn big input a u64 . output u8 . do
  return cast u8 gt a. 2 . . .
end .

fn count_big input a u64 . input b u64 . output u64 . do
  return add cast u64 gt a. 2 . . cast u64 gt b. 2 . . . .
end .

big(5) = 1 · big(1) = 0 · count_big(5, 7) = 2

module ex_cast_to_bool .
fn nonzero input n u64 . output bool . do
  return cast bool n. . .     rem 무엇을 묻는지 적는다 — `ne n. 0 .`
end .

5 열거 값은 수가 아니다. 수를 받는 자리 — 수로 선언된 이름 · 칸 · 인자 · 반환, 셈, 수와의 견줌, 첨자, 비트 연산, 넓히기 · 좁히기 — 에 열거 값을 두면 번역이 거부되고(E-TYPE-KIND · E-TYPE-LET · E-TYPE-RETURN · E-TYPE-ARG · E-WIDEN-KIND), 열거를 받는 자리에 수를 두는 것도 리터럴까지 거부된다. 갈래의 번호(§6.2.7 (2c))가 필요하면 cast <정수 타입> <열거 값> 으로 적는다 — 번호가 그 타입에 들어가지 않으면 (2) 대로 트랩한다. 같은 열거의 두 값은 eq · ne 로, 그리고 lt · le · gt · ge 로 견줄 수 있다 — 크기는 번호의 차례이고, 번호는 선언된 차례대로 오르므로 선언의 차례와 같다. 다른 열거의 값끼리는 견주지 아니한다(E-TYPE-KIND).

5a 수에서 열거로는 cast <열거> <정수> 로 간다 — 그 번호를 가진 갈래를 낸다. 어느 갈래의 번호도 아닌 수이면 트랩한다 (E-VM-CAST). 파일이나 선에서 읽은 수를 열거로 되돌리는 자리가 이것이다. 원천은 정수여야 한다(E-TYPE-KIND).

5b 값을 지닌 갈래(§6.2.19)가 하나라도 있는 열거는 cast 의 원천도 대상도 될 수 없다(E-TYPE-KIND). 번호 하나로는 그 값이 다 말해지지 않는다 — 어느 갈래인지는 isa · match 로 묻고, 값은 <열거>.<갈래> … 로 짓는다.

module ex_enum_cast .

enum color do
  red .
  green .
  blue .
end .

fn code input c color . output u8 . do
  return cast u8 c. . .
end .

fn code_of_blue output u8 . do
  return code blue. . .
end .

fn same output u8 . do
  return cast u8 eq green. green. . . .
end .

code_of_blue() = 3 · same() = 1

module ex_enum_as_number .

enum color do
  red .
  green .
end .

fn code input c color . output u8 . do
  return c. .     rem 갈래의 번호는 `cast u8 c. .` 로 읽는다
end .

module ex_enum_from_number .

enum item do
  weapon_start 10 .
  sword .
  stick .
  weapon_end .
  tool_start 20 .
  hammer .
  tool_end .
end .

rem 1 = 무기 · 2 = 도구 — 같은 열거의 값은 크기로 견준다
fn kind_of input n u8 . output u8 . do
  let it item cast item n. . .
  if and gt it. weapon_start. . lt it. weapon_end. . . do return 1 . end .
  if and gt it. tool_start. . lt it. tool_end. . . do return 2 . end .
  return 0 .
end .

enum hangul do
  ga 11 .
  na .
  da 101 .
  ra .
end .

fn round_trip input n u32 . output u32 . do
  return cast u32 cast hangul n. . . .
end .

kind_of(12) = 1 · kind_of(21) = 2 · round_trip(102) = 102

module ex_enum_cross_order .

enum color do
  red .
  green .
end .

enum size do
  small .
  large .
end .

fn f input c color . input s size . output bool . do
  return lt c. s. . .
end .

module ex_enum_arith .

enum level do
  low .
  high .
end .

fn next input l level . output u8 . do
  return add l. 1 . .
end .

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

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

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

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

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

6.2.18 뜻이 없는 타입 이름§

1 어떤 이름은 받아들여지되 뜻이 없다. 그런 이름을 시그니처에 적으면 처리기는 경고한다(W-NOT-YET). 그 이름들은 부록 A.9 (2) 에 모여 있다 — byte · char · str · string · bytes_view · dyn · atomic 과 같은 것들이다.

2 뜻이 없다는 것은 처리기가 그 이름이 담는 값의 모양을 모른다는 말이다. 크기도, 배치도, 그 값에 할 수 있는 일도 정해지지 않았으므로, 그 이름에 기대는 검사는 서지 아니한다.

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

module ex_name_only .

rem `str` 은 내장이 아니다 — 뜻을 주지 않으면 W-NOT-YET 을 받는다. 여기서는 선언하여 뜻을 주었다.
type str option u64 .

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

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

5b 갈래가 지니는 것의 타입은 낱말 하나로 적는다(E-ENUM-PAYLOAD). 갈래 한 줄에는 칸 사이를 가르는 표시가 없어서, 여러 낱말로 적는 타입(slice u8 · option t · owned t · ref t)은 어디서 끊기는지 정해지지 아니하기 때문이다. 이것은 철자의 제한이지 크기의 제한이 아니다 — 지니는 값의 크기는 묻지 아니한다. 여러 낱말 타입은 그것을 칸으로 가진 구조체에 이름을 붙여 그 이름으로 적는다.

module ex_enum_named_payload .

struct bytes do
  b slice u8 .
end .

struct pt do
  x u64 .
  y u64 .
  z u64 .
end .

enum msg do
  data d bytes .
  dot p pt .
  blank .
end .

fn size_of_data input m msg . output usize . do
  guard isa m. data . else return 0 . .
  let d bytes payload m. data d . .
  return len field d. b . . .
end .

export fn f input s slice u8 . output usize . do
  let m msg msg.data lit bytes do b s. . end . . .
  return size_of_data m. . .
end .

export fn g output u64 . do
  let m msg msg.dot lit pt do x 1 . y 2 . z 7 . end . . .
  guard isa m. dot . else return 0 . .
  let p pt payload m. dot p . .
  return add add field p. x . field p. y . . field p. z . . .
end .

f([1,2,3]) = 3 · g() = 10

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

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

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

1a 눈은 칸 back(뒤의 바이트)과 descs(서술자)를 든 묶음이다. 조각의 수와 번호의 조각은 그 칸을 읽고 잘라내는 것으로 쓰이므로 언어의 연산이 아니라 표준 모듈 segview 의 op 이다(§9.3).

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.2.25 정했으되 짓지 않은 타입 낱말 — c8…c64 · b8…b128 · list · 겹치는 합 · 자식 영역§

1 이 조항의 낱말은 §6.9.4 의 넷처럼 뜻이 정해져 있되 처리기가 아직 짓지 않은 것이다. 철자가 정해진 셋(아래 (2)   (4))은 타입 자리에 쓰면 번역이 거부된다(E-TYPE-UNBUILT) — 받아서 뜻 없는 이름으로 두거나 다른 타입으로 돌리지 아니한다. 셋 모두 예약어가 아니다: 저자가 그 이름의 타입을 선언하면(type c8 u8 .) 그 선언이 서고, 같은 이름의 지역 · op 도 선다.

2 c8 · c16 · c32 · c64 는 글자의 부호 단위(code unit)다 — 그 수만큼의 비트로 된, 어떤 인코딩의 한 단위. 수가 아니므로 셈하지 아니한다. 정수와 오가는 것은 cast 로만이다(§6.2.16).

3 b8 · b16 · b32 · b64 · b128 은 속을 모르는 바이트 덩이다 — 그 수만큼의 바이트이고, 정렬은 크기다. 셈도 견줌도 없이 옮기고 베끼기만 한다. 수나 구조로 읽으려면 창(§6.2.13)을 거친다.

4 list 는 원소마다 타입이 다를 수 있는 목록이다. 원소마다 그 타입의 표지와 값의 자리를 지니며, 핸들로만 닿는다(값으로 놓이는 확정 타입이 아니다). 그 목록의 원소를 쓰는 op 은 표지로 갈래를 고른다.

5 겹치는 합 — 같은 자리에 갈래 가운데 하나를 놓는 타입이며, 크기는 가장 큰 갈래의 것이다. 철자는 짓을 때 정한다: 원안의 union 은 언어가 짧은 낱말을 저자에게 남긴다는 규칙(§6.3.3 (1e) — 집합의 합도 bitset_union 이다)과 부딪친다. 그래서 이 갈래는 낱말로 거부되지 않는다.

6 자식 영역 — 다른 영역에서 깎아 낸 영역이며, 부모가 끝날 때 함께 끝난다(어휘 블록이 끝날 때가 아니다). 깎아 내는 것은 새 메모리를 얻지 않으므로 alloc 효과가 아니다(§8.13). 원안의 철자(child_of)는 지금 문법에 자리가 없으므로, 철자는 짓을 때 정한다.

7 유예. 이 낱말들은 쓰임이 나올 때 짓는다. 다른 길이 그 쓰임을 다 채워 필요 없다고 보이면 버린다. 지금 그 쓰임을 맡은 것: 부호 단위는 정수(u8 · u16 · u32)와 라이브러리 utf8 · utf16 · 바이트 덩이는 slice u8 · array N u8 과 창 · list 는 값을 담는 열거(§6.2.7) · 겹치는 합은 값을 담는 열거 · 자식 영역은 얼로케이터(§8.13). 짓을지 버릴지는 소유자가 정한다. 그때까지 이 조항은 남고 처리기는 (2)   (4) 의 낱말을 계속 알아본다.

module ex_unbuilt_type .

fn f input x c8 . output u64 . do
  return 0 .
end .

6.3.1 전위 표기가 기본이다§

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

2 전위 표기에는 우선순위 규칙이 없다. 어떤 것이 먼저 계산되는지는 점과 순서가 전부 말해 준다 — 폼은 이름으로 열리고 제 점으로 닫히며(§6.1.5), 안쪽 폼이 먼저 닫힌다.

2a 부름을 겹쳐 적는 데 괄호가 들지 아니한다 — add 1 mul a. b. . . 에서 첫 점이 mul 을, 둘째 점이 add 를 닫는다. 폼의 끝은 그 폼의 점이 정한다. 연산이 받는 인자 수는 끝을 정하지 아니한다 — 인자 수가 맞는지는 폼이 닫힌 뒤에 따로 본다(맞지 아니하면 E-IR-ARITY).

2b 괄호는 묶음을 눈에 띄게 하는 꾸밈이다 — add 1 (mul a. b. .) . 는 (2a) 의 식과 같은 식이다. 괄호 안의 폼도 제 점으로 닫히고, 괄호는 뜻을 바꾸지 아니한다.

2c 피연산자를 계산하는 차례는 자유 선택 (free choice) 이다(§4.3). 처리기는 한 연산의 피연산자들을 어느 차례로든 계산할 수 있다. 기본 연산 · 빌트인 연산과 저자가 선언한 op 이 같다. 다만 다음은 정해져 있다.

• 피연산자를 모두 계산한 뒤에 그 연산을 한다.
• 피연산자마다 한 번씩만 계산한다.
• 효과를 내는 피연산자들은 적힌 차례로, 왼쪽부터 계산한다. 여기서 효과는 panic 밖의 효과를 말한다(§7) —

멈출 수 있다는 것만으로는 차례가 묶이지 아니한다.

• and 와 or 는 예외다 — 앞 피연산자를 먼저 계산하고, 그것만으로 결과가 정해지면 뒤 피연산자를

계산하지 아니한다(§6.3.3 (4)).

let a u32 add 1 2 . .
let b u32 add 1 mul 2 3 . . .
let c bool 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 언어가 뜻을 정해 둔 연산은 두 갈래다. 기본 연산 (core op) 은 어디서나 제 이름만으로 부르며, 저자가 지은 이름과 한 이름공간을 쓴다. 빌트인 연산 (builtin op) 은 call_builtin 뒤에서만 부르며, 제 이름공간을 따로 갖는다((1c) · (1f)). 두 갈래 모두 이름의 목록은 고정되어 있고, 전체는 부록 D 에 있다. 부록 D 는 연산마다 무엇을 받고 무엇을 내는지, 언제 번역이 거부되고 언제 실행이 멈추는지도 적는다.

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

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

1c 빌트인 연산은 머리말 call_builtin 뒤에서만 선다: call_builtin <이름> <피연산자>*. 그 이름은 닫힌 집합이며 부르는 자리는 그 하나뿐이다. 어느 이름이 그러한지는 부록 D 가 적는다. 바깥 세상에 닿는 것 — 파일 · 그물 · 프로세스(file_* · dir_* · path_remove · path_rename · link_type · net_* · proc_*), 표준 입출력(write_out · read_in), 인자와 환경(arg · env_get), 시계(time_now · time_local · time_sleep), 터미널(tty_raw · tty_read · tty_size), 난수(random_bytes), reactor(reactor_new · r_read · r_write) — 은 첫 피연산자가 권한이다: call_builtin net_send <권한> <핸들> <바이트>.

1c-1 권한을 받지 아니하는 빌트인 연산은 계산이다 — 부동소수점 함수(§6.3.9), 조각의 합(§6.3.7.1), 그리고 해시 · 암호 · 캐리 없는 곱셈 · 난수 열(hash_bytes · crc32 · sha256 · sha384 · sha512 · aes_round · aes_round_last · aes_ctr · ghash · aes_gcm · chacha20 · poly1305 · chacha_poly · clmul_lo · clmul_hi · mul_hi · rng_next).

1c-2 표준 라이브러리는 이 빌트인 연산들을 감싼 op 을 내놓는다(§9.3 (1a)) — stdio · args · env · clock · tty · random · reactor · math 따위다. 감싸개는 피연산자를 그대로 넘기므로 뜻이 같다.

1f 빌트인 연산의 이름공간은 저자의 이름공간과 따로다. call_builtin 바로 뒤의 낱말은 언제나 빌트인 연산의 이름으로 읽고, 그 밖의 자리에 선 같은 철자는 언제나 저자의 이름으로 읽는다. 그러므로 저자는 빌트인 연산과 같은 철자를 제 op · 매개변수 · 지역의 이름으로 지을 수 있고, 한 단위 안에서 둘을 함께 쓸 수 있다. 낱말이 선 자리가 어느 쪽인지를 정하므로, 한 철자가 한 자리에서 두 뜻을 갖는 일은 없다.

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 usize . effects none .
do
  return call_builtin sha256 s. o. . .
end .

module ex_both .

fn sha256 input x u64 . output u64 . do
  return add x. 1 . .
end .

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

1e 언어가 뜻을 정한 이름을 전역 어휘에서 가두는 길은 셋이다.

• 머리 — call_builtin <이름> 의 이름 자리((1c)). 빌트인 연산이 그렇다.
• 접두사 — 한 무리의 op 이 같은 앞마디를 나눈다: bitset_*(작은 수의 집합, §6.2.12) ·

lane_* 와 reduce_*(레인) · atomic_* · wrap_* · sat_* · chk_* · narrow_*. 접두사가 붙은 이름은 전역 이름이지만, 그 무리가 짧은 낱말(union · remove · select · any …)을 차지하지 아니하므로 저자가 그 낱말을 제 이름으로 쓸 수 있다.

• 자리 — 정해진 문맥 안에서만 뜻이 있는 낱말. pipe 의 스테이지와 종결자가 그렇다(§6.12):

종결자 any · all 은 pipe 안의 낱말이고, 레인의 판정은 lane_any · lane_all 이다. 한 op 의 철자는 하나다. 이름을 옮길 때 옛 철자를 동의어로 남기지 아니한다.

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

2a mod 는 정수의 나머지다. 부동소수점 수의 나머지는 fmod(§6.3.9)이며, 부동소수점 피연산자에 mod 를 쓰면 번역이 거부된다(E-TYPE-KIND, 2026-11-02 — 그 전에는 검사를 지나 실행 중에 멈췄다).

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

3a 정수끼리의 비교는 산술과 같은 규칙을 따른다 — 두 피연산자가 넓히기로 견줄 수 있어야 하고, 그럴 수 없으면 번역이 거부된다(E-TYPE-SIGN, §6.3.4 (1)). 처리기는 비교를 위해 부호를 몰래 바꾸지 아니한다. 부호나 폭이 달라도 두 정수의 수학적 값을 견주려면 표준 라이브러리 intops 의 cmp_eq · cmp_lt · cmp_le 를 이름으로 부른다(§9) — intops.cmp_lt i64. u64. a. b. . 는 a 가 −1 이고 b 가 0 일 때 참이다. 그 op 들은 어느 정수 타입의 짝이든 받는다(usize · idiff · 128 비트 포함).

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

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

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

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

8 neg 는 부호를 뒤집는다. 피연산자는 부호 있는 정수이거나 부동소수점 수여야 한다 — 부호 없는 정수에는 음수가 없으므로 번역이 거부된다(E-TYPE-SIGN). 결과의 타입은 피연산자의 타입이다.

8a neg 도 산술이다. 결과가 그 폭에 들어가지 않으면 멈춘다(§6.3.4 (3)) — 부호 있는 타입의 가장 작은 값이 그 경우다(i8 의 −128).

6.3.4 산술의 규칙§

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

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

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

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

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

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

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

5a div 는 몫을 0 쪽으로 자른다 — div -7 2 . 는 −3 이다.

5b mod 는 바닥 나눗셈의 나머지다. 나머지의 부호는 제수를 따른다 — mod -7 2 . 는 1, mod 7 -2 . 는 −1 이다. 그러므로 제수가 양수이면 결과는 언제나 0 이상이고 제수보다 작다: 0 < n 이면 0 ≤ mod i n < n 이며, i 가 음수여도 그렇다.

5c 그러므로 div 와 mod 는 서로 짝이 아니다. (div a b) × b + (mod a b) 가 a 와 같은 것은 두 수의 부호가 같거나 나누어떨어질 때뿐이다. 0 쪽으로 자른 몫과 짝인 나머지는 sub a. mul div a. b. . b. . . 로 적는다.

5d 부호 있는 타입의 가장 작은 값을 −1 로 나눈 mod 는 0 이다. div 는 같은 자리에서 멈추지만(몫이 그 폭에 없다) 나머지 0 은 그 폭 안에 있다.

5e 짝이 맞는 몫과 나머지는 표준 라이브러리 intops 에 있다(§9) — div_floor 는 mod 의 짝인 바닥 몫이고 ((div_floor a b) × b + (mod a b) 는 언제나 a 다), mod_trunc 는 div 의 짝인 자른 나머지다(부호는 피제수를 따른다 — mod_trunc -7 2 는 −1). 둘 다 타입을 인자로 받고(intops.div_floor i64. a. b. .), 0 으로 나누면 멈추며, 부호 있는 타입의 가장 작은 값을 −1 로 나눈 div_floor 도 div 처럼 멈춘다. 모두 로우엔트로 적혀 있다(§9.3 (5)).

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 비트 연산은 값을 비트의 나열로 보고 다룬다. 피연산자와 결과는 정수이며, 부호 있는 정수도 다룰 수 있다.

1′ bit_and · bit_or · bit_xor 의 두 피연산자가 같은 타입이면 결과도 그 타입이고, 한쪽이 리터럴이면 다른 쪽의 타입이다. bit_not 과 옮기기 · 돌리기(shl · shr · rotl · rotr)의 결과는 (왼쪽) 피연산자의 타입이다. usize · idiff 와 고정 폭 정수를 한 연산에 대면 번역이 거부된다(E-TYPE-NOMINAL, §6.2 (3-2)) — 옮기는 양은 이 규칙에 들지 않는다.

1″ bit_and · bit_or · bit_xor 의 두 피연산자가 폭이나 부호만 다른 정수이면 산술과 같은 규칙을 따른다(§6.3.4 (1)–(2)): 넓히기로 비교할 수 있으면 결과는 넓은 쪽의 타입이고, 그럴 수 없으면 번역이 거부된다(E-TYPE-SIGN). count_ones · leading_zeros · trailing_zeros 의 결과는 a 의 타입이다.

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

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

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

3a 돌리기의 칸 수는 어느 정수 타입이어도 되며, 폭으로 나눈 나머지만큼 돌린다 — 폭이 8 인 타입을 9 칸 돌리면 1 칸 돌린 것과 같다. 돌리기는 멈추지 아니한다.

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

4a shl · shr · wrap_shl · wrap_shr 의 칸 수는 부호 없는 정수 타입이다(폭은 무엇이든 좋다). 부호 있는 정수 타입의 값을 칸 수로 대면 번역이 거부된다(E-SHIFT-SIGNED) — 음수 칸 수에는 하나로 정해진 뜻이 없다. 부호 있는 값을 칸 수로 쓰려면 부호 없는 타입으로 명시적으로 바꾼다. 리터럴은 자리의 타입을 받으므로 그대로 쓴다(음수 리터럴은 (9)).

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

module ex_shift_signed .

fn up input a u8 . input n i8 . output u8 . do return shl a. n. . . end .

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 부호 있는 정수 — 빈자리에 부호 비트가 들어온다(산술 이동). 칸 수는 부호 없는 타입이다((4a)).
fn s_shr input a i32 . input n u32 . 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

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

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

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

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

1a 넘침 처분을 적은 셈(wrap_* · sat_* · chk_*)은 정수의 것이다. 부동소수점 수에 쓰면 번역이 거부된다(E-TYPE-KIND) — 부동소수점 셈에는 넘친 값이 갈 무한대가 있다.

2 나눗셈의 0 도 같다. 제수가 0 이 아님이 타입으로 보장된 자리에서는 div_nz 를 쓰며, 그 자리에는 검사가 남지 아니한다. 보장된 제수는 셋이다 — 0 이 아닌 정수 리터럴 · (2a) 의 값을 some_value 로 꺼낸 것 · 그것으로 묶은 let. (2c) 의 nonzero_or 가 내는 값과 그것으로 묶은 let 도 보장된 제수다. 그 밖의 제수를 div_nz 에 주면 번역이 거부된다(E-TYPE-NONZERO). 0 에서 멈추는 나눗셈은 div 다.

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

2b 넘친 자리올림 · 빌림을 버리지 않고 값으로 받으려면 표준 라이브러리 intops 를 쓴다(§9) — add_carry_<폭> 은 합과 자리올림(0 또는 1)을, sub_borrow_<폭> 은 차와 빌림을, mul_wide_<폭> 은 곱의 아래 절반 lo 와 위 절반 hi 를 구조체로 돌려준다(부호 있는 폭은 mul_wide_s_<폭> — lo 는 부호 없고 hi 는 부호 있다). 폭은 부호 없는 u8 · u16 · u32 · u64 · usize 와 부호 있는 i8 · i16 · i32 · i64 · idiff 다. 모두 로우엔트로 적혀 있다(§9.3 (5)).

2c nonzero_or <값> <대신> 은 값이 0 이 아니면 그 값을, 0 이면 대신을 낸다. 대신은 값과 같은 타입이고 0 이 아님이 보장된 값이어야 한다 (0 이 아닌 정수 리터럴 · nonzero_of 의 값을 some_value 로 꺼낸 것 · 그것으로 묶은 let · 다른 nonzero_or 의 결과) — 아니면 번역이 거부된다(E-TYPE-NONZERO). 그러므로 결과도 0 이 아님이 보장되어, div_nz 의 제수가 되고 그것으로 묶은 let 도 그렇다: div_nz total. nonzero_or count. 1 . .. 정수만 받는다(E-TYPE-KIND).

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

6.3.7 레인을 다루는 op§

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

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

1b lane_avg 는 정수 레인의 것이다(위의 값이 정수의 셈이다). 부동소수점 레인에 쓰면 번역이 거부된다(E-TYPE-KIND, 2026-11-02).

1c 레인을 다루는 op 은 벡터를 받는다. 수 하나를 주면 번역이 거부된다(E-TYPE-KIND).

1d splat <리터럴> 의 리터럴은 레인 하나를 그 레인 타입의 자리로 보고 §6.1.4 (8)(9) 를 따른다 — 부동소수점 레인에 정수 리터럴을 채우면 E-TYPE-LET, f32 레인에 그 범위를 넘는 부동소수점 리터럴을 채우면 E-TYPE-WIDTH 다. 나열 리터럴(lit vec · lit array · lit slice)의 원소도 같다.

2 레인을 가로지르는 op 은 레인 수만큼을 하나로 모은다. 결과의 타입은 레인의 타입이다. 부호 있는 레인은 부호로 더하고 곱하며, reduce_add · reduce_mul 의 값이 그 타입에 들어가지 않으면 멈춘다(§6.3.4 (3)).

6.3.7.1 조각을 더한다§

1 조각(⟦slice⟧)에 담긴 부동소수점 수를 모두 더하는 빌트인 연산은 둘이며, 이름이 어떻게 더하는지를 말한다. 표준 라이브러리 math 가 같은 이름의 op 으로 감싼다(math.sum_neumaier · math.sum_seq).

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

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

module ex_slice_sum .

use math .

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

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

6.3.8 크기를 묻는다 — size_of§

1 size_of <타입> 은 그 타입 값 하나가 차지하는 바이트 수를 번역 시점에 준다. 그 수의 타입은 usize 다 — align_of 가 주는 정렬, native_lanes 가 주는 레인의 수도 같다.

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

6.3.9 초월 함수§

1 빌트인 연산 sin · cos · exp · log · pow · sqrt · floor · ceil · round · fmod 는 부동소수점 전용이다. 표준 라이브러리 math 가 같은 이름의 op 으로 감싼다(math.sqrt x.). 응용 프로그램은 그 op 을 부른다.

1a abs 는 부동소수점 수와 부호 있는 정수를 받는다. 결과의 타입은 피연산자의 타입이다. 부호 있는 정수의 가장 작은 값에서는 멈춘다 — 절댓값이 그 폭에 없다(§6.3.4 (3)). 부호 없는 정수에 쓰면 번역이 거부된다(E-TYPE-SIGN) — 그 값이 이미 제 절댓값이다.

module ex_abs_unsigned .

fn f input a u32 . output u32 . do
  return abs a. . .     rem 부호 없는 값은 이미 제 절댓값이다
end .

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

6.3.10 참거짓은 수가 아니다§

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

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

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

4 참거짓은 셈(add · sub · mul · div · mod · min · max · abs 와 넘침 처분을 적은 셈) · 크기 견줌(lt · le · gt · ge) · 비트 연산(bit_and · bit_or · bit_xor)의 피연산자가 될 수 없다(E-TYPE-KIND). 두 참거짓은 eq · ne 로 견준다. 참거짓을 수로 세려면 cast u8 b. . 로 적는다(§6.2.16 (4)).

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 4 u8 . input b vec 8 u8 . output vec 4 u8 .
do
  return add a. b. . .
end .

6.3.12 expr 섬 안의 규칙§

1 expr 섬(§6.3.2) 안의 토막은 저마다 폼 하나다 — 이름이면 a., 호출이면 제 점으로 닫힌 폼이다 (expr twice a. . + 1 .). 폼이 제 끝을 스스로 가지므로 호출을 괄호로 묶을 필요가 없다. 섬은 제 점으로 닫힌다.

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

module m .
fn flip input a i32 . output i32 . do
  return expr - a. . .
end .

6.4.1 op 의 선언§

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

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

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

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

3a 머리의 절은 한 가지 차례로만 적는다. 앞에서 뒤로: satisfies·lowdoc · vector·priority · comptime 입력 · 권한·영역 입력(타입이 cap …·region …) · use · 데이터 입력 · 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)는 입력이 아닌 절과 use 절을 이 차례로 옮겨 적는다. 입력끼리의 차례는 옮기지 아니한다 — 입력을 옮기면 호출의 뜻이 바뀌기 때문이다.

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

3d (3a) 의 차례에 나온 절 낱말의 뜻과 정의 자리는 다음과 같다.

• satisfies — 이 op 이 지키는 이름 붙은 약속(§6.4.5 · §6.11.2). lowdoc — 사람이 읽는 설명(§6.4.3).
• vector · priority — 이 op 을 인터럽트 처리기로 만든다: 받는 인터럽트의 번호와 그 급함(§7.7).
• comptime 입력 — 번역 시점에 정해지는 매개변수(§6.8). 권한 입력 — 효과를 낼 자격(§7.2).
• use — 이 op 이 쓰는 얼로케이터(§8.14).
• link · variadic — C 쪽의 이름 · 개수가 정해지지 않은 인자(§7.4).
• asm — 기계 명령을 직접 적는 자리(§6.9.1).
• absorbs · reference · why — unsafe 가 번지는 것을 여기서 멈춘다는 선언과, 그 근거가 되는 순수한 판 · 가정한 것(§7.2.1).
• access · inplace · invalidates — 무엇을 어떤 모드로 건드리는가 · 제자리 쓰기 · 무효로 하는 것(§6.4.3 · §8.12).
• parallel · reduce — 나누어 도는 되풀이와, 걸음들이 모으는 자리(§6.5.10).
• requires · ensures · errors · tests — 계약의 절(§6.4.3).
• schedule — 시험(test) 머리에만 온다. schedule explore_interleavings . 은 메시지가 배달되는 차례를 모두

돌려 보고 결과가 차례마다 같은지 본다. limit <수> 를 붙이면 그 수까지만 돈다. 차례에 따라 결과가 갈리면 그 시험은 실패한다(E-SCHED-NONDET). 뜻은 §6.4.13 (4) 가 정한다.

3e 출력에 이름을 붙일 수 있다 — output <이름> <타입> .. 그 이름은 몸의 지역이고 0 으로 시작한다: 수는 0 · 0.0, bool 은 false, option 은 none, 구조체는 칸마다 그 칸의 0 이다. 몸은 그 이름에 쓰고 return <이름> . 으로 돌려준다(값을 돌려주는 다른 op 과 같이 모든 길이 return 으로 끝나야 한다 — §6.5.5 (3)).

• 가름: 이름 공간이 하나이므로(§6.10) output 뒤의 첫 낱말이 타입 이름이면 출력 전체가 타입이고,

타입 이름이 아니고 그 뒤가 타입 하나이면 그 낱말이 결과의 이름이다.

• 0 이 정해지지 않은 타입(슬라이스 · result · owned · enum · newtype · 제네릭 매개변수, 그런 칸을 가진 구조체)에는

이름을 붙일 수 없다(E-RESULT-NOZERO). 그런 출력은 이름 없이 적고 값을 돌려준다.

• 몸이 없는 op(extern · trait 의 메서드 서명)은 결과에 이름을 붙일 수 없다(E-RESULT-NAMED).
• 배열을 돌려주는 출력(output [<이름>] array <길이> <타입> .)은 부르는 쪽이 자리를 준다 — §6.2.6 (1c).
• ensures 는 결과를 여전히 ret 으로 가리킨다(§6.4.12). 결과의 이름은 몸 안에서만 보인다.

module ex_named_result .

struct span do
  lo u64 .
  hi u64 .
  seen bool .
end .

export fn bounds input xs slice u64 . output s span .
do
  for x xs. do
    if or not field s. seen . . lt x. field s. lo . . . do set field s. lo . x. . end .
    if gt x. field s. hi . . do set field s. hi . x. . end .
    set field s. seen . true .
  end .
  return s. .
end .

module ex_named_nozero .

fn first input xs slice u8 . output r slice u8 .
do
  return xs. .
end .

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 계약은 다음 여섯 절로 이루어진다. 모든 절이 필수는 아니다.

1a tests <이름>… 절은 이 op 을 시험하는 op 의 이름을 하나 이상 적는다. 적은 이름은 그 자리에서 볼 수 있는 op 이어야 하며, 없으면 거부된다(E-CONTRACT-UNDEF). 시험 블록(§6.4.13)의 이름은 op 이 아니므로 여기 적을 수 없다. tests 절은 시험을 정의하지도 돌리지도 아니한다 — 이미 있는 것을 가리킬 뿐이다. 가리킨 op 이 없어지면 머리가 그것을 알린다.

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, idx 를 쓸 수 있다.

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 widen u32 idx data. 0 . . .
  let lo u32 widen u32 idx 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 .

 proven 250  ──▶ requires le a 200   entry check fails → E-VM-CONTRACT (caller's fault)
 proven 150  ──▶ requires le a 200   passes → from here on a ∈ [0, 200] is a fact
                 add a 1             a + 1 ∈ [1, 201] ⊂ u8 [0, 255] → overflow check removed
 bare 255    ──▶ add a 1             no fact about a → the check stays → E-VM-OVERFLOW

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

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

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

2 debug 는 남은 검사를 두고, 깨지면 무엇이 깨졌는지 말하며 멈춘다 — 깨진 검사의 종류(requires · ensures · errors 절)와 그 검사를 가진 op 의 이름, 그리고 그 절의 소스 줄을 알린다. test 도 그렇게 알린다.

2a test 는 debug 와 같이 검사를 둔다. 시험(§6.4.13)을 돌리는 것은 이 모드가 아니라 시험을 돌리라는 요청이다 — 그 요청은 어느 모드에서든 시험을 돌리고, test 모드라도 보통의 실행은 시험을 돌리지 아니한다. 시험 안의 expect 가 거짓이면 그 시험은 실패한다(E-TEST-FAIL) — 처리기의 잘못이 아니라 적은 사람의 주장이 틀린 것이다.

3 release_safe 는 남은 검사를 두고, 깨지면 멈춘다. 멈출 때 알리는 것은 깨진 검사의 종류를 적은 짧은 고정 문구다 — 계약의 글(소스의 식)은 실행 파일에 싣지 아니한다. debug 와 다른 점은 (4) 대로 debug 등급의 계약을 없애는 것이다.

4 release_fast 는 증명하지 못한 requires 의 검사를 없앤다 — op 에 적은 것도, satisfies 로 들인 명명 계약의 것도. release_safe 는 debug 등급의 requires 검사를 없앤다. 어느 모드도 ensures 의 출구 검사는 없애지 아니한다.

4a 모드가 검사를 없앤 계약은 사실이 아니다. 처리기는 그 계약을 근거로 다른 검사를 지우지 아니한다 — 그 op 은 그 계약이 적혀 있지 않았던 것처럼 돈다. 그러므로 계약을 어긴 부름이 그 op 안에서 넘치거나 범위를 벗어나면, 그 셈의 검사가 멈춘다. assume 이 사실이 아닌 것(§6.4.9)과 같은 까닭이다.

4b 처리기가 셈마다 넣는 검사 — 넘침 · 0 으로 나누기 · MIN / -1 · 첨자 · 미는 칸 수 · 좁히기 · 태그 — 는 어느 모드에서도 없어지지 아니한다. 그 검사는 증명될 때에만 없어진다.

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

5a 값 자리에 적은 이름은 그 자리에서 살아 있는 대상 — 지역 · 입력 · op · 상수 · 열거의 갈래 — 을 가리켜야 한다. 아무것도 가리키지 않으면 번역이 거부된다(E-IR-UNDEF). 처리기는 그 이름을 짚어 말한다.

5b 지역은 선언한 뒤에야 산다 — 선언보다 앞에서 쓰면 (5a) 대로 거부된다. 모듈에 선언한 이름(op · 상수 · 타입)은 선언의 차례와 상관없이 그 모듈 어디에서나 산다: 뒤에 선언한 op 을 앞에서 불러도 된다.

module ex_undeclared .

fn f input a u64 . output u64 . do
  return add a. b. . .
end .

module ex_shadow .

let g u32 7 .

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

module ex_shadow_param .

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

module ex_shadow_twice .

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