Compact grammar

Compact language version 0.21.0.

Notational note: In the grammar below, terminals are in monospaced font. Non-terminals are in emphasized font. Alternation is indicated by a vertical bar (|). Optional items are indicated by the superscript ^opt. Repetition is specified by ellipses. The notation X … X, where X is a grammar symbol, represents zero or more occurrences of X. The notation X , … , X, where X is a grammar symbol and , is a literal comma, represents zero or more occurrences of X separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one X. When such a sequence is followed by ,^opt, an optional trailing comma is allowed, but only if there is at least one X. For example, id … id represents zero or more ids, and expr , …¹ , expr ,^opt represents one or more comma-separated exprs possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when , is replaced by ;.

end-of-file (eof)

End of file.

identifier (id, module-name, function-name, struct-name, enum-name, contract-name, tvar-name, type-name)

Identifiers have the same syntax as Typescript identifiers.

field-literal (nat)

A field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value.

string-literal (str, file)

A string literal has the same syntax as a Typescript string.

version-literal (version)

A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions.

Compact (program)

program	⟶	pelt … pelt eof

Program-element (pelt)

pelt	⟶	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-form	⟶	pragma id version-expr ;

Version-expression (version-expr)

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

Version-expression₀ (version-expr₀)

version-expr0	⟶	version-expr0 && version-term
	|	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)

version-atom	⟶	nat
	|	version

Include (include-form)

include-form	⟶	include file ;

Module-definition (module-definition)

module-definition	⟶	exportopt module module-name gparamsopt { pelt … pelt }

Generic-parameter-list (gparams)

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

Generic-parameter (generic-param)

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

Import-declaration (import-form)

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

Import-selection (import-selection)

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

Import-element (import-element)

import-element	⟶	id
	|	id as id

Import-name (import-name)

import-name	⟶	id
	|	file

Import-prefix (import-prefix)

import-prefix	⟶	prefix id

Generic-argument-list (gargs)

gargs	⟶	< garg , … , garg ,opt >

Generic-argument (garg)

garg	⟶	nat
	|	type

Export-declaration (export-form)

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

Ledger-declaration (ledger-declaration)

ledger-declaration	⟶	exportopt sealedopt ledger id : type ;

Witness-declaration (witness-declaration)

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

Constructor (constructor-definition)

constructor-definition	⟶	constructor pattern-parameter-list block

Circuit-definition (circuit-definition)

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

Structure-declaration (struct-declaration)

struct-declaration	⟶	exportopt struct struct-name gparamsopt { typed-identifier ; … ; typed-identifier ;opt } ;opt
	|	exportopt struct struct-name gparamsopt { typed-identifier , … , typed-identifier ,opt } ;opt

Enum-declaration (enum-declaration)

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

External-contract-declaration (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)

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

Type-declaration (type-alias-declaration)

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

Typed-identifier (typed-identifier)

typed-identifier	⟶	id : type

Simple-parameter-list (simple-parameter-list)

simple-parameter-list	⟶	( typed-identifier , … , typed-identifier ,opt )

Typed-pattern (typed-pattern)

typed-pattern	⟶	pattern : type

Pattern-parameter-list (pattern-parameter-list)

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

Type (type)

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

Type-reference (tref)

tref	⟶	id gargsopt

Type-size (tsize)

tsize	⟶	nat
	|	id

Block (block)

block	⟶	{ stmt … stmt }

Statement (stmt)

stmt	⟶	if ( expr-seq ) stmt
	|	stmt0

Statement₀ (stmt₀)

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)

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

Pattern-struct-element (pattern-struct-elt)

pattern-struct-elt	⟶	id
	|	id : pattern

Expression-sequence (expr-seq)

expr-seq	⟶	expr
	|	expr , …¹ , expr , expr

Expression (expr)

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

Expression₀ (expr₀)

expr0	⟶	expr0 || expr1
	|	expr1

Expression₁ (expr₁)

expr1	⟶	expr1 && expr2
	|	expr2

Expression₂ (expr₂)

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

Expression₃ (expr₃)

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

Expression₄ (expr₄)

expr4	⟶	expr4 as type
	|	expr5

Expression₅ (expr₅)

expr5	⟶	expr5 + expr6
	|	expr5 - expr6
	|	expr6

Expression₆ (expr₆)

expr6	⟶	expr6 * expr7
	|	expr7

Expression₇ (expr₇)

expr7	⟶	! expr7
	|	expr8

Expression₈ (expr₈)

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

Expression₉ (expr₉)

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 [ tuple-arg , … , tuple-arg ,opt ]
	|	tref { struct-arg , … , struct-arg ,opt }
	|	assert ( expr , str )
	|	disclose ( expr )
	|	term

Term (term)

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

Tuple-argument (tuple-arg, bytes-arg)

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

Structure-argument (struct-arg)

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

Function (fun)

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

Return-type (return-type)

return-type	⟶	: type

Optionally-typed-pattern (optionally-typed-pattern)

optionally-typed-pattern	⟶	pattern
	|	typed-pattern

Const-Binding (cbinding)

cbinding	⟶	optionally-typed-pattern = expr

Arrow-parameter-list (arrow-parameter-list)

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