Compact Grammar

Compact language version 0.14.0.

Notational note: In the grammar productions below, ellipses are used to specify repetition. The notation X ... X, where X is a grammar symbol, represents zero or more occurrences of X. The notation X s ... s X, where X is a grammar symbol and s is a separator such as a comma or or semicolon, represents zero or more occurrences of X separated by s. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one X. For example, id … id represents zero or more ids, and expr , …¹ , expr represents one or more comma-separated exprs.

end-of-file (eof)

end of file

identifier (id, module-name, function-name, struct-name, enum-name, contract-name, tvar-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
 →  incld
 →  mdefn
 →  idecl
 →  xdecl
 →  ldecl
 →  lconstructor
 →  cdefn
 →  edecl
 →  wdecl
 →  ecdecl
 →  struct
 →  enumdef

Pragma (pragma)

pragma →  pragma  id  version-expr  ;

Version-expression (version-expr)

version-expr →  version-expr  ||  version-expr0
 →  version-expr0

Version-expression0 (version-expr0)

version-expr0 →  version-expr0  &&  version-term
 →  version-term

Version-Term (version-term)

version-term →  version-atom
 →  !  version-term
 →  <  version-atom
 →  <=  version-atom
 →  >=  version-atom
 →  >  version-atom
 →  (  version-expr  )

Version-atom (version-atom)

version-atom →  nat
 →  version

Include (incld)

incld →  include  file  ;

Module-definition (mdefn)

mdefn →  exportopt  module  module-name  gparamsopt  {  pelt … pelt  }

Generic-parameter-list (gparams)

gparams →  <  generic-param , … , generic-param  >

Generic-parameter (generic-param)

generic-param →  #  tvar-name
 →  tvar-name

Import-declaration (idecl)

idecl →  import  import-name  gargsopt  prefixopt  ;

Import-name (import-name)

import-name →  id
 →  file

Generic-argument-list (gargs)

gargs →  <  garg , … , garg  >

Import-prefix (prefix)

prefix →  prefix  id

Export-modifier (export)

export →  export

Sealed-modifier (sealed)

sealed →  sealed

Pure-modifier (pure)

pure →  pure

Export-declaration (xdecl)

xdecl →  export  {  id , … , id  }  ;opt

Ledger-declaration (ldecl)

ldecl →  exportopt  sealedopt  ledger  id  :  type  ;

Constructor (lconstructor)

lconstructor →  constructor  (  parg , … , parg  )  block  ;opt

Circuit-definition (cdefn)

cdefn →  exportopt  pureopt  circuit  function-name  gparamsopt  (  parg , … , parg  )  :  type  block

External-declaration (edecl)

edecl →  exportopt  circuit  id  gparamsopt  (  arg , … , arg  )  :  type  ;

Witness-declaration (wdecl)

wdecl →  exportopt  witness  id  gparamsopt  (  arg , … , arg  )  :  type  ;

External-contract-declaration (ecdecl)

ecdecl →  exportopt  contract  contract-name  {  ecdecl-circuit … ecdecl-circuit  }  ;opt

External-contract-circuit (ecdecl-circuit)

ecdecl-circuit →  pureopt  circuit  id  (  arg , … , arg  )  :  type  ;

Structure-definition (struct)

struct →  exportopt  struct  struct-name  gparamsopt  {  arg ; … ; arg  ;opt  }  ;opt
 →  exportopt  struct  struct-name  gparamsopt  {  arg , … , arg  ,opt  }  ;opt

Enum-definition (enumdef)

enumdef →  exportopt  enum  enum-name  {  id , …¹ , id  ,opt  }  ;opt

Argument (arg)

arg →  id  :  type

Pattern-argument (parg)

parg →  pattern  :  type

Type (type)

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

Type-reference (tref)

tref →  id  gargsopt

Type-size (tsize)

tsize →  nat
 →  id

Generic-argument (garg)

garg →  nat
 →  type

Block (block)

block →  {  stmt … stmt  }

Statement (stmt)

stmt →  expr  =  expr  ;
 →  expr  +=  expr  ;
 →  expr  -=  expr  ;
 →  expr-seq  ;
 →  return  expr-seq  ;
 →  return  ;
 →  if  (  expr-seq  )  stmt  else  stmt
 →  if  (  expr-seq  )  stmt
 →  for  (  const  id  of  nat  ..  nat  )  stmt
 →  for  (  const  id  of  expr-seq  )  stmt
 →  assert  expr  str  ;
 →  const  pattern  =  expr  ;
 →  const  pattern  :  type  =  expr  ;
 →  block

Pattern (pattern)

pattern →  id
 →  [  pattern-tuple-elt , … , pattern-tuple-elt  ]
 →  {  pattern-struct-elt , … , pattern-struct-elt  }

Pattern-tuple-element (pattern-tuple-elt)

pattern-tuple-elt →  (empty)
 →  pattern

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

Expression0 (expr0)

expr0 →  expr0  ||  expr1
 →  expr1

Expression1 (expr1)

expr1 →  expr1  &&  expr2
 →  expr2

Expression2 (expr2)

expr2 →  expr2  ==  expr3
 →  expr2  !=  expr3
 →  expr3

Expression3 (expr3)

expr3 →  expr4  <  expr4
 →  expr4  <=  expr4
 →  expr4  >=  expr4
 →  expr4  >  expr4
 →  expr4

Expression4 (expr4)

expr4 →  expr4  as  type
 →  expr5

Expression5 (expr5)

expr5 →  expr5  +  expr6
 →  expr5  -  expr6
 →  expr6

Expression6 (expr6)

expr6 →  expr6  *  expr7
 →  expr7

Expression7 (expr7)

expr7 →  !  expr7
 →  expr8

Expression8 (expr8)

expr8 →  expr8  [  nat  ]
 →  expr8  .  id
 →  expr8  .  id  (  expr , … , expr  )
 →  term

Term (term)

term →  lit
 →  default  <  type  >
 →  map  (  fun  ,  expr , …¹ , expr  )
 →  fold  (  fun  ,  expr  ,  expr , …¹ , expr  )
 →  fun  (  expr , … , expr  )
 →  disclose  (  expr  )
 →  tref  {  struct-arg , … , struct-arg  }
 →  [  expr , … , expr  ,opt  ]
 →  id
 →  (  expr-seq  )

Literal (lit)

lit →  true
 →  false
 →  nat
 →  str
 →  pad  (  nat  ,  str  )

Structure-argument (struct-arg)

struct-arg →  expr
 →  id  :  expr
 →  ...  expr

Function (fun)

fun →  id  gargsopt
 →  (  pattern-or-parg , … , pattern-or-parg  )  return-type-declopt  =>  block
 →  (  pattern-or-parg , … , pattern-or-parg  )  return-type-declopt  =>  expr
 →  (  fun  )

Return-type-declaration (return-type-decl)

return-type-decl →  :  type

Pattern-or-pattern-argument (pattern-or-parg)

pattern-or-parg →  pattern
 →  parg