Skip to main content
Version: v1

Compact grammar

Compact 언어 버전 0.22.0.

표기법: 아래 문법에서 키워드와 구두점은 고정폭 글꼴로, 터미널 및 비터미널 이름은 강조 글꼴로 표기합니다. 대안은 수직 막대(|)로, 선택 항목은 위첨자 opt로 나타냅니다. 반복은 줄임표로 표현하며, X ⋯ X(여기서 X는 문법 기호)는 X가 0회 이상 나타남을 의미합니다. X , ⋯ , X(여기서 X는 문법 기호, ,는 리터럴 쉼표)는 쉼표로 구분된 X의 0회 이상 발생을 의미합니다. 줄임표에 위첨자 1이 붙으면 최소 하나의 X가 필요합니다. 이러한 시퀀스 뒤에 ,opt가 오면, X가 하나 이상일 때만 후행 쉼표가 허용됩니다. 예를 들어, id ⋯ id는 0개 이상의 id를, expr , ⋯¹, expr ,opt는 하나 이상의 쉼표로 구분된 expr에 선택적 후행 쉼표가 올 수 있음을 나타냅니다. 쉼표 관련 규칙은 세미콜론에도 동일하게 적용됩니다.

identifier​

id, module-name, function-name, struct-name, enum-name, contract-name, tvar-name, type-name

식별자 구문은 TypeScript 식별자와 동일합니다.

field-literal​

nat

필드 리터럴은 0이거나 1-9로 시작하는 숫자열로 구성된 자연수(예: 723)이며, 최대 필드 값을 초과할 수 없습니다.

string-literal​

str, file

문자열 리터럴 구문은 TypeScript 문자열과 동일합니다.

version-literal​

version

버전 리터럴은 메이저 및 마이너 버전을 나타내는 nat.nat 형식 또는 메이저, 마이너 및 버그픽스 버전을 나타내는 nat.nat.nat 형식입니다. 버전 리터럴이 허용되는 곳에서는 메이저 버전만 나타내는 일반 nat도 허용됩니다.

Compact​

program⟶program-element ⋯ program-element

Program-element​

program-element⟶pragma-form
|module-definition
|import-form
|export-form
|include-form
|struct-declaration
|enum-declaration
|contract-declaration
|type-alias-declaration
|ledger-declaration
|witness-declaration
|constructor-definition
|circuit-definition

Pragma​

pragma-form⟶pragma id version-expr ;

Version-expression​

version-expr⟶version-expr || version-expr0
|version-expr0

Version-expression0​

version-expr0⟶version-expr0 && version-term
|version-term

Version-Term​

version-term⟶version-atom
|! version-atom
|< version-atom
|<= version-atom
|>= version-atom
|> version-atom
|( version-expr )

Version-atom​

version-atom⟶nat
|version

Include​

include-form⟶include file ;

Module-definition​

module-definition⟶exportopt module module-name gparamsopt { program-element ⋯ program-element }

Generic-parameter-list​

gparams⟶< generic-param , ⋯ , generic-param ,opt >

Generic-parameter​

generic-param⟶# tvar-name
|tvar-name

Import-declaration​

import-form⟶import import-selectionopt import-name gargsopt import-prefixopt ;

Import-selection​

import-selection⟶{ import-element , ⋯ , import-element ,opt } from

Import-element​

import-element⟶id
|id as id

Import-name​

import-name⟶id
|file

Import-prefix​

import-prefix⟶prefix id

Generic-argument-list​

gargs⟶< garg , ⋯ , garg ,opt >

Generic-argument​

garg⟶nat
|type

Export-declaration​

export-form⟶export { id , ⋯ , id ,opt } ;opt

Ledger-declaration​

ledger-declaration⟶exportopt sealedopt ledger id : type ;

Witness-declaration​

witness-declaration⟶exportopt witness id gparamsopt simple-parameter-list : type ;

Constructor​

constructor-definition⟶constructor pattern-parameter-list block

Circuit-definition​

circuit-definition⟶exportopt pureopt circuit function-name gparamsopt pattern-parameter-list : type block

Structure-declaration​

struct-declaration⟶exportopt struct struct-name gparamsopt { typed-id ; ⋯ ; typed-id ;opt } ;opt
|exportopt struct struct-name gparamsopt { typed-id , ⋯ , typed-id ,opt } ;opt

Enum-declaration​

enum-declaration⟶exportopt enum enum-name { id , ⋯¹ , id ,opt } ;opt

External-contract-declaration​

contract-declaration⟶exportopt contract contract-name { circuit-declaration ; ⋯ ; circuit-declaration ;opt } ;opt
|exportopt contract contract-name { circuit-declaration , ⋯ , circuit-declaration ,opt } ;opt

External-contract-circuit​

circuit-declaration⟶pureopt circuit id simple-parameter-list : type

Type-declaration​

type-alias-declaration⟶exportopt newopt type type-name gparamsopt = type ;

Typed-identifier​

typed-id⟶id : type

Simple-parameter-list​

simple-parameter-list⟶( typed-id , ⋯ , typed-id ,opt )

Typed-pattern​

typed-pattern⟶pattern : type

Pattern-parameter-list​

pattern-parameter-list⟶( typed-pattern , ⋯ , typed-pattern ,opt )

Type​

type⟶tref
|Boolean
|Field
|Uint < tsize >
|Uint < tsize .. tsize >
|Bytes < tsize >
|Opaque < str >
|Vector < tsize , type >
|[ type , ⋯ , type ,opt ]

Type-reference​

tref⟶id gargsopt

Type-size​

tsize⟶nat
|id

Block​

block⟶{ stmt ⋯ stmt }

Statement​

stmt⟶if ( expr-seq ) stmt
|stmt0

Statement0​

stmt0⟶expr-seq ;
|const cbinding , ⋯¹ , cbinding ;
|if ( expr-seq ) stmt0 else stmt
|for ( const id of nat .. nat ) stmt
|for ( const id of expr-seq ) stmt
|return expr-seq ;
|return ;
|block

Pattern​

pattern⟶id
|[ patternopt , ⋯ , patternopt ,opt ]
|{ pattern-struct-elt , ⋯ , pattern-struct-elt ,opt }

Pattern-struct-element​

pattern-struct-elt⟶id
|id : pattern

Expression-sequence​

expr-seq⟶expr
|expr , ⋯¹ , expr , expr

Expression​

expr⟶expr0 ? expr : expr
|expr0 = expr
|expr0 += expr
|expr0 -= expr
|expr0

Expression0​

expr0⟶expr0 || expr1
|expr1

Expression1​

expr1⟶expr1 && expr2
|expr2

Expression2​

expr2⟶expr2 == expr3
|expr2 != expr3
|expr3

Expression3​

expr3⟶expr4 < expr4
|expr4 <= expr4
|expr4 >= expr4
|expr4 > expr4
|expr4

Expression4​

expr4⟶expr4 as type
|expr5

Expression5​

expr5⟶expr5 + expr6
|expr5 - expr6
|expr6

Expression6​

expr6⟶expr6 * expr7
|expr7

Expression7​

expr7⟶! expr7
|expr8

Expression8​

expr8⟶expr8 [ expr ]
|expr8 . id
|expr8 . id ( expr , ⋯ , expr ,opt )
|expr9

Expression9​

expr9⟶fun ( expr , ⋯ , expr ,opt )
|map ( fun , expr , ⋯¹ , expr ,opt )
|fold ( fun , expr , expr , ⋯¹ , expr ,opt )
|slice < tsize > ( expr , expr )
|[ tuple-arg , ⋯ , tuple-arg ,opt ]
|Bytes [ bytes-arg , ⋯ , bytes-arg ,opt ]
|tref { struct-arg , ⋯ , struct-arg ,opt }
|assert ( expr , str )
|disclose ( expr )
|term

Term​

term⟶id
|true
|false
|nat
|str
|pad ( nat , str )
|default < type >
|( expr-seq )

Tuple-argument​

tuple-arg⟶expr
|... expr
bytes-arg⟶tuple-arg

Structure-argument​

struct-arg⟶expr
|id : expr
|... expr

Function​

fun⟶id gargsopt
|arrow-parameter-list return-typeopt => block
|arrow-parameter-list return-typeopt => expr
|( fun )

Return-type​

return-type⟶: type

Optionally-typed-pattern​

optionally-typed-pattern⟶pattern
|typed-pattern

Const-Binding​

cbinding⟶optionally-typed-pattern = expr

Arrow-parameter-list​

arrow-parameter-list⟶( optionally-typed-pattern , ⋯ , optionally-typed-pattern ,opt )