coolguy/coollang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

grammar: v0 EBNF 확정과 열린 문법 결정 8건

Browse Source 
열려 있던 문법 항목을 언어 철학에 따라 전부 닫고 EBNF로 고정한다.

- 제네릭 인자를 대괄호로 통일(List[a], map[Int, String](...)). <>는 식
  위치에서 비교 연산자와 갈리지 않아 turbofish라는 제2 표기를 부르는데,
  effect 규칙이 명시적 인스턴스화 문법을 요구하므로 회피할 수 없다.
  대괄호는 전위=리터럴 / 후위=인스턴스화로 위치가 결정해 LL(1)이고 표기가
  하나다. 대가로 인덱싱 연산자를 두지 않는다.
- 파라미터 규칙을 callable 한정에서 전 파라미터로 일반화. 기본은 빌림,
  own만 소유 이전. capability를 예외로 두지 않는 이유는 capability의 존재가
  이미 타입과 effects 절에 드러나기 때문이다 — 표기가 실을 정보는 소유 이동뿐.
- 문 구분은 줄바꿈(Go식 자동 삽입), 블록은 식, return은 조기 탈출 전용.
  if/match를 식으로 두면 재대입이 줄어 move 검사가 단순해진다.
- match 가드 없음. 가드는 exhaustiveness를 흐리고 SMT 없이는 _ 분기를
  강요한다. 철학 1의 대표 항목을 문법 편의와 바꾸지 않는다.
- ?는 Result 전용 하드코딩. 조기 탈출도 블록 종료이므로 scope의 join/cancel이
  ? 경로에서도 실행된다. v1 linear 도입 시 이 경로가 암묵 drop 문제와 만난다.
- 수식어 순서는 바인딩(own, mut) 먼저, 타입(affine) 나중.

docs/grammar.ebnf는 LL(1)을 설계 제약으로 명시하고, effect 합집합을
결과 위치 전용 프로덕션으로 새겨 파라미터 위치의 역산을 파서가 거부하게 한다.
samples/는 확정 표기로 전면 갱신.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019ZVDeU6KLuUVL3gs18Hm3E
This commit is contained in:
coolguy
2026-08-30 02:09:58 +09:00
co-authored by Claude Opus 5
parent e3b19b1300
commit 630d12104a
9 changed files with 329 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/grammar.ebnf
+181
View File
@@ -0,0 +1,181 @@
(* coollang v0 문법 — EBNF
*
* 표기 규약:
* = 정의
* | 선택
* [ ] 선택적 (0 또는 1)
* { } 반복 (0 이상)
* ( ) 묶음
* " " 단말
* (* *) 주석
*
* 설계 제약: LL(1). backtracking 없음, 렉서 피드백 없음.
* 어떤 프로덕션도 무한 선읽기를 요구해서는 안 된다 (철학 2).
*)
(* ------------------------------------------------------------------ *)
(* 어휘 *)
(* ------------------------------------------------------------------ *)
(* 주석은 // 부터 줄 끝까지. 블록 주석 없음 (중첩 규칙이라는 변종을 만들지 않는다) *)
(* 문 구분자 NEWLINE은 렉서가 삽입한다:
* 줄의 마지막 토큰이 ident, 리터럴, ")", "]", "}", "?", "return" 중 하나이면
* 그 줄 끝에 NEWLINE 토큰을 넣는다. 그 외에는 넣지 않는다.
* 따라서 연산자나 여는 괄호로 끝나는 줄은 다음 줄로 이어진다.
* 빈 줄과 주석만 있는 줄은 NEWLINE을 만들지 않는다.
*)
ident = letter , { letter | digit | "_" } ;
int_lit = digit , { digit | "_" } ;
string_lit = '"' , { char - '"' } , '"' ;
bool_lit = "true" | "false" ;
literal = int_lit | string_lit | bool_lit ;
(* ------------------------------------------------------------------ *)
(* 모듈 *)
(* ------------------------------------------------------------------ *)
module = { NEWLINE } , { item } ;
item = ( import | reexport | decl ) , NEWLINE ;
import = "import" , string_lit , "as" , ident ;
reexport = "reexport" , ident ;
decl = [ "pub" ] , ( fn_decl | struct_decl | enum_decl
| capability_decl | const_decl ) ;
(* ------------------------------------------------------------------ *)
(* 선언 *)
(* ------------------------------------------------------------------ *)
fn_decl = "fn" , ident , [ gen_params ] , "(" , [ params ] , ")" ,
[ eff_result ] , [ "->" , type ] , [ block ] ;
(* block이 없으면 시그니처 선언. interface 파일과 capability 본문에서 쓴다 *)
struct_decl = [ "copyable" ] , "struct" , ident , [ gen_params ] ,
"{" , { field } , "}" ;
field = ident , ":" , type , "," , { NEWLINE } ;
enum_decl = "enum" , ident , [ gen_params ] , "{" , { variant } , "}" ;
variant = ident , [ "(" , type_list , ")" ] , "," , { NEWLINE } ;
capability_decl = "capability" , ident , "{" , { cap_method } , "}" ;
cap_method = "fn" , ident , "(" , [ params ] , ")" ,
[ eff_result ] , [ "->" , type ] , NEWLINE ;
const_decl = "const" , ident , ":" , type , "=" , expr ;
gen_params = "[" , gen_param , { "," , gen_param } , [ "," ] , "]" ;
gen_param = ident , [ ":" , "effects" ] ;
(* ident 단독 = 타입 파라미터, ": effects" = effect 파라미터 *)
params = param , { "," , param } , [ "," ] ;
param = [ "own" ] , [ "mut" ] , ident , ":" , type ;
(* 무표기 = use(빌림). own만이 소유 이전을 뜻한다.
* 수식어 순서 고정: 바인딩 수식어(own, mut)가 먼저, 타입 수식어(affine)는 type 안 *)
(* ------------------------------------------------------------------ *)
(* effect 절 *)
(* ------------------------------------------------------------------ *)
(* 결과 위치 — 함수 선언 자신의 effect. 합집합 허용 *)
eff_result = "effects" , eff_union ;
eff_union = eff_atom , { "|" , eff_atom } ;
(* 파라미터 위치 — 함수 타입 안의 effect. 합집합이 문법에 없다.
* "검사기가 거부"가 아니라 "그런 문장이 존재하지 않음"이다 *)
eff_param = "effects" , eff_atom ;
eff_atom = ident | eff_set ;
eff_set = "{" , [ eff_name , { "," , eff_name } , [ "," ] ] , "}" ;
eff_name = ident , "." , ident ;
(* 타입 수준 이름만. capability 값의 identity는 정적 층에 등장하지 않는다 *)
(* ------------------------------------------------------------------ *)
(* 타입 *)
(* ------------------------------------------------------------------ *)
type = fn_type | named_type ;
fn_type = [ "affine" ] , "fn" , "(" , [ type_list ] , ")" ,
[ eff_param ] , [ "->" , type ] ;
named_type = ident , [ type_args ] ;
type_args = "[" , type , { "," , type } , [ "," ] , "]" ;
type_list = type , { "," , type } , [ "," ] ;
(* ------------------------------------------------------------------ *)
(* 문과 블록 *)
(* ------------------------------------------------------------------ *)
block = "{" , { NEWLINE } , { stmt } , "}" ;
stmt = ( let_stmt | return_stmt | assign_stmt | expr ) , NEWLINE ;
let_stmt = "let" , [ "mut" ] , pattern , [ ":" , type ] , "=" , expr ;
return_stmt = "return" , [ expr ] ;
assign_stmt = place , "=" , expr ;
place = ident , { "." , ident } ;
(* 블록의 값 = 마지막 stmt가 expr이면 그 값, 아니면 Unit.
* return은 조기 탈출 전용이며, 꼬리 위치의 return은 formatter가 지적한다 *)
(* ------------------------------------------------------------------ *)
(* 식 *)
(* ------------------------------------------------------------------ *)
expr = or_expr ;
or_expr = and_expr , { "||" , and_expr } ;
and_expr = cmp_expr , { "&&" , cmp_expr } ;
cmp_expr = add_expr , [ cmp_op , add_expr ] ;
cmp_op = "==" | "!=" | "<" | "<=" | ">" | ">=" ;
add_expr = mul_expr , { ( "+" | "-" ) , mul_expr } ;
mul_expr = unary , { ( "*" | "/" | "%" ) , unary } ;
unary = [ "!" | "-" ] , postfix ;
postfix = primary , { call_sfx | field_sfx | inst_sfx | "?" } ;
call_sfx = "(" , [ args ] , ")" ;
field_sfx = "." , ident ;
inst_sfx = type_args ;
(* 후위 "[" = 명시적 인스턴스화, 전위 "[" = 리스트 리터럴. 위치가 결정한다 *)
args = expr , { "," , expr } , [ "," ] ;
primary = literal
| ident
| list_lit
| struct_lit
| closure
| if_expr
| match_expr
| scope_expr
| "(" , expr , ")" ;
list_lit = "[" , [ expr , { "," , expr } , [ "," ] ] , "]" ;
(* 빈 리스트는 타입 주석이 필요하다: let xs: List[Int] = [] *)
struct_lit = ident , "{" , { field_init } , "}" ;
field_init = ident , ":" , expr , "," , { NEWLINE } ;
closure = "fn" , "(" , [ cl_params ] , ")" ,
[ eff_param ] , [ "->" , type ] , block ;
cl_params = cl_param , { "," , cl_param } , [ "," ] ;
cl_param = ident , [ ":" , type ] ;
(* 파라미터 타입 생략 가능. 호출 지점의 기대 타입에서 읽어온다 — 함수 로컬이다.
* 기대 타입이 없는 자리에서 생략하면 error *)
if_expr = "if" , expr_ns , block , [ "else" , ( block | if_expr ) ] ;
match_expr = "match" , expr_ns , "{" , { arm } , "}" ;
arm = pattern , "=>" , ( expr | block ) , "," , { NEWLINE } ;
scope_expr = "scope" , ident , block ;
(* expr_ns = struct_lit로 시작하지 않는 expr.
* if/match/scope의 머리 자리에서 "{"가 블록의 시작인지 struct 리터럴인지
* 갈리지 않으므로, 그 자리의 struct 리터럴은 괄호로 감싼다 *)
(* ------------------------------------------------------------------ *)
(* 패턴 *)
(* ------------------------------------------------------------------ *)
pattern = "_" | literal | ctor_pattern | ident ;
ctor_pattern = ident , "(" , pattern , { "," , pattern } , [ "," ] , ")" ;
(* 가드 없음. 중첩은 제한 없음 (exhaustiveness 알고리즘이 처리한다) *)
docs/thesis.md
+29 -4
View File
@@ -66,15 +66,18 @@ Capability 전달 (Alias/Move 모델의 제3의 규칙):
죽이므로 기각. 별도의 nonescaping 개념을 만들지 않고 use의 전염으로 정의해
"한 개념 한 방식"을 지킨다 (Swift @noescape, second-class values의 검증된 경로)
- 소유권 이전이 필요할 때만 명시적 move
- 파라미터 위치의 callable은 기본이 use(비탈출)이고, 저장하는 쪽이 own fn으로
유표기한다. 파라미터 밖(반환 타입, struct 필드, channel 원소)의 callable은
use가 애초에 불가능한 위치이므로 무표기로 항상 owned 의미다
- 파라미터 위치는 전부 기본이 use(빌림)이고, 소유 이전만 own으로 유표기한다.
capability든 callable이든 일반 affine 값이든 규칙은 하나다
※ 무표기-흔함 / 유표기-위험은 이미 언어의 다른 곳에 있는 규칙이다
(effect 없는 함수가 무표기, effect 있는 쪽이 effects 유표기).
새 조항이 아니라 같은 원칙의 적용이다
※ 반대로 두면 클로저를 저장하지 않는 고차 함수 — 즉 표준 라이브러리의 거의 전부 —
가 use 표기로 도배된다. 위험한 쪽(클로저를 오래 보관하는 sink)에 표기가 가야
가 표기로 도배된다. 위험한 쪽(소유를 가져가는 쪽)에 표기가 가야
리뷰어의 눈이 그리로 간다
※ capability를 별도 규칙으로 두지 않는 이유: capability의 존재는 이미 타입과
effects 절에 드러난다. 표기가 실어야 할 정보는 "소유가 옮겨가는가"뿐이다
- 파라미터 밖(반환 타입, struct 필드, channel 원소)은 use가 애초에 불가능한
위치이므로 무표기로 항상 owned 의미다
- capability가 셋 이상 필요하면 capability struct로 접는다 (표준 관용구):
struct Deps { pay: PaymentGateway, log: Logger, db: Database }
use deps: Deps로 받으면 affinity 전이와 use 규칙이 그대로 적용되므로
@@ -223,6 +226,28 @@ Generics (철학 2에서 파생):
- coollang 단독 표기 (스탠퍼드 Cool과 구별, golang 방식 검색성 확보)
- .cool (충돌 제로, 확장자 생략은 toolchain이 허용)
표기 (철학 2,5에서 파생 — 문법 상세는 docs/grammar.ebnf):
- 제네릭 인자는 대괄호 하나로 통일: List[a], map[Int, String](xs, f)
※ <>는 식 위치에서 비교 연산자와 갈리지 않아 turbofish 같은 제2 표기를 부른다.
대괄호는 전위=리스트 리터럴 / 후위=인스턴스화로 위치가 결정하므로 LL(1)이고
표기가 하나로 끝난다. 대가로 인덱싱 연산자를 두지 않는다 (List.at을 쓴다)
※ effect 규칙이 "합집합 위치에서는 명시적 인스턴스화 요구"이므로 식 위치의
인스턴스화 문법은 반드시 존재해야 한다. 추론으로 회피할 수 없다
- 수식어 순서: 바인딩 수식어(own, mut)가 먼저, 타입 수식어(affine)가 뒤:
own affine fn(...) effects e -> b
- 문 구분은 줄바꿈이다 (Go식 자동 삽입). 공식 formatter가 하나뿐이라 함정이 봉쇄된다
- 블록은 식이다. 마지막 식이 블록의 값이고 return은 조기 탈출 전용
※ if와 match가 식이면 let x = if c { a } else { b }를 재대입 없이 쓸 수 있다.
mutable 변수와 덮어쓰기가 줄면 move 검사가 그만큼 단순해진다 — 기준은 검증기다
- match 가드는 v0에 없다
※ 가드가 붙는 순간 그 분기가 패턴 전체를 덮는다고 말할 수 없어 exhaustiveness가
흐려지고, SMT 없이는 보수적으로 _ 분기를 강요하게 된다. 철학 1의 대표 항목을
문법 편의와 바꾸지 않는다. 필요하면 분기 본문에서 if를 쓴다
- ?는 Result 전용으로 하드코딩한다 (trait solver가 없으므로 일반화 경로가 없다)
※ 조기 탈출도 블록 종료이므로 scope의 join/cancel은 ? 경로에서도 실행된다
※ v1에서 linear를 넣으면 ?의 조기 탈출 경로마다 해제가 필요해진다.
이것이 암묵 drop 문제와 만나는 지점이다 — linear 설계는 이 제약을 안고 시작한다
■ v0 — "기능의 서브셋, 아키텍처의 풀셋"
목표: 시스템 속성(빠른 검증 루프)은 측정으로만 증명된다.
성공 기준(숫자): 10만 줄 규모에서 함수 수정 시 check 50ms 이내.