Compact Grammar

Compact language version 0.5.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.

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

identifiers have the same syntax as Typescript identifiers

adt-identifier (adt-name)

identifier that names one of the Ledger ADTs

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

Program-element (pelt)

pelt →  pragma
 →  incld
 →  mdefn
 →  idecl
 →  xdecl
 →  ldecl
 →  cdefn
 →  edecl
 →  wdecl
 →  struct
 →  enumdef

Pragma (pragma)

pragma →  pragma  id  version-expr  ;

Version-expression (version-expr)

The productions on each line of this group have lower precedence than those on the lines that follow and are either left or right associative as marked.

version-expr →  version-expr || version-expr  (left)
→  version-expr && version-expr  (left)
→  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  tparamsopt  {  pelt … pelt  }

Type-params (tparams)

tparams →  [  type-param , … , type-param  ]

Import-declaration (idecl)

idecl →  import  module-name  targsopt  prefixopt  ;

Type-args (targs)

targs →  [  targ , … , targ  ]

Import-prefix (prefix)

prefix →  prefix  id

Export (export)

export →  export

Pure (pure)

pure →  pure

Export-declaration (xdecl)

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

Ledger-Declaration (ldecl)

ldecl →  ledger  {  ldecl-elt … ldecl-elt  }

Ledger-Declaration-Element (ldecl-elt)

ldecl-elt →  id  :  ledger-adt  ;
 →  constructor  (  arg , … , arg  )  block

Circuit-definition (cdefn)

cdefn →  exportopt  pureopt  circuit  function-name  tparamsopt  (  arg , … , arg  )  :  return-type  block

External-declaration (edecl)

edecl →  exportopt  circuit  id  tparamsopt  (  arg , … , arg  )  :  return-type  ;

Witness-declaration (wdecl)

wdecl →  exportopt  witness  id  tparamsopt  (  arg , … , arg  )  :  return-type  ;

Structure-definition (struct)

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

Enum-definition (enumdef)

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

Ledger-adt (ledger-adt)

Midnight ledger ADTs are described here.

ledger-adt →  adt-name  adt-argsopt

Ledger-adt-args (adt-args)

adt-args →  [  ledger-adt-arg , …¹ , ledger-adt-arg  ]

Ledger-ADT-Arg (ledger-adt-arg)

ledger-adt-arg →  nat
 →  adt-type

Ledger-ADT-Type (adt-type)

adt-type →  type
 →  ledger-adt

Argument (arg)

arg →  id  :  type

Return-Type (return-type)

return-type →  Void
 →  type

Type (type)

type →  tref
 →  Boolean
 →  Field
 →  Unsigned  Integer  [  nat  ]
 →  Unsigned  Integer  [  <=  nat  ]
 →  Bytes  [  tsize  ]
 →  Opaque  [  str  ]
 →  Vector  [  tsize  ,  type  ]

Type-ref (tref)

tref →  id  targsopt

Type-size (tsize)

tsize →  nat
 →  id

Type-argument (targ)

targ →  nat
 →  type

Block (block)

block →  {  stmt … stmt  }

Statement (stmt)

stmt →  expr  ;
 →  return  expr  ;
 →  return  ;
 →  if  (  expr  )  stmt  else  stmt
 →  if  (  expr  )  stmt
 →  for  id  =  nat  to  nat  do  stmt
 →  for  id  in  expr  do  stmt
 →  assert  expr  str  ;
 →  const  id  =  expr  ;
 →  const  id  :  adt-type  =  expr  ;
 →  block

Expression (expr)

expr →  map  fun  over …¹ over
 →  fold  fun  expr  over …¹ over
 →  expr0  ?  expr  :  expr
 →  ledger  .  id  ledger-accessor … ledger-accessor  =  expr
 →  ledger  .  id  ledger-accessor … ledger-accessor  +=  expr
 →  ledger  .  id  ledger-accessor … ledger-accessor  -=  expr
 →  expr0

Over (over)

over →  over  expr

Function (fun)

fun →  id  targsopt
 →  circuit  (  arg , … , arg  )  :  return-type  block
 →  (  fun  )

Expression0 (expr0)

The productions on each line of this group have lower precedence than those on the lines that follow and are either left or right associative as marked.

expr0 →  expr0 || expr0  (left)
→  expr0 && expr0  (left)
→  expr0 == expr0  |  expr0 != expr0  |  expr0 < expr0  |  expr0 > expr0  |  expr0 <= expr0  |  expr0 >= expr0  (left)
→  expr1

Expression1 (expr1)

expr1 →  expr2  tail-expr1

Expression1-tail (tail-expr1)

tail-expr1 →  (empty)
 →  as  type  tail-expr1

Expression2 (expr2)

The productions on each line of this group have lower precedence than those on the lines that follow and are either left or right associative as marked.

expr2 →  expr2 + expr2  |  expr2 - expr2  (left)
→  expr2 * expr2  (left)
→  expr3

Expression3 (expr3)

expr3 →  !  expr3
 →  expr4

Expression4 (expr4)

expr4 →  term  tail-expr4

Expression4-tail (tail-expr4)

tail-expr4 →  (empty)
 →  [  nat  ]  tail-expr4
 →  .  id  tail-expr4

Term (term)

term →  lit
 →  id
 →  null  (  type  )
 →  null  (  ledger-adt  )
 →  fun  (  expr , … , expr  )
 →  new  tref  (  expr , … , expr  )
 →  [  expr , … , expr  ,opt  ]
 →  (  expr  )
 →  (  expr , …¹ , expr  ,  expr  )
 →  ledger  ledger-accessor
 →  ledger  .  id  ledger-accessor … ledger-accessor

Ledger-Accessor (ledger-accessor)

ledger-accessor →  .  id  (  expr , … , expr  )

Literal (lit)

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