The Language Tenet

BNF-converter

August 22, 2020

This document was automatically generated by the BNF-Converter. It was generated together with the lexer, the parser, and the abstract syntax module, which guarantees that the document matches with the implementation of the language (provided no hand-hacking has taken place).

The lexical structure of Tenet

Literals

Integer literals Int  are nonempty sequences of digits.

String literals String  have the form "x", where x is any sequence of any characters except " unless preceded by \.

ValId literals are recognized by the regular expression lower (letter digit ‘_’)

TypId literals are recognized by the regular expression upper (letter digit ‘_’)

Reserved words and symbols

The set of reserved words is the set of terminals appearing in the grammar. Those reserved words that consist of non-letter characters are called symbols, and they are treated in a different way from those that are similar to identifiers. The lexer follows rules familiar from languages like Haskell, C, and Java, including longest match and spacing conventions.

The reserved words used in Tenet are the following:

Func and as
break case catch
continuedef default
else eqv false
for func gen
if imp import
in let meta
not or pass
return switchtenet
true try type
xor

The symbols used in Tenet are the following:

( ) {
} . ;
, : >
# ˜ +
* |
= = ! = <
< = > > =
++ ||
/ // %
&& ... [
] .. ?
!! #( !Unspec
: = = + =
= * = / =
// = % = ++ =
|| =&& = =

Comments

Single-line comments begin with ;;.
There are no multiple-line comments in the grammar.

The syntactic structure of Tenet

Non-terminals are enclosed between and . The symbols ::= (production), | (union) and 𝜖 (empty rule) belong to the BNF notation. All other symbols are terminals.

Module ::=ListPragma ListStatement 

TopStmt ::= Pragma 
|Statement 

Pragma ::= tenet Integer 
|meta PragmaWord  ( ListPragmaArg  )
|gen ListGenName  { ListGenConfig  }
|import ListModName  . NameSpec 
|import ListModName  ( ListNameSpec  )
|Pragma  ;

ListPragma ::= 𝜖
|Pragma ListPragma 

PragmaArg ::= Integer 
|String 
|ValId 
|TypId 

ListPragmaArg ::= 𝜖
|PragmaArg 
|PragmaArg  , ListPragmaArg 

GenConfig ::= PragmaWord 
|PragmaWord  ( ListPragmaArg  )

ListGenConfig ::= 𝜖
|GenConfig ListGenConfig 

NameSpec ::= ValId 
|ValId  as ValId 
|TypId 
|TypId  as TypId 

ListNameSpec ::= NameSpec 
|NameSpec  , ListNameSpec 

Statement ::= type TypeLhsExpr AssignOp TypeExpr 
|def LetLhsExpr AssignOp ValExpr 
|let LetLhsExpr AugAssignOp ValExpr 
|LetLhsExpr AugAssignOp ValExpr 
|func ValId  ( ListSigArg  ) SigReturn Block 
|if ValExpr Block ElseClause 
|switch ValExpr CaseBlock 
|try Block ListCatchClause 
|for ValId  in ValExpr Block 
|return ValExpr 
|pass
|continue
|break
|Statement  ;

ListStatement ::= Statement 
|Statement ListStatement 

SigArg ::= ValId 
|ValId  : TypeExpr 
|TypId 

ListSigArg ::= 𝜖
|SigArg 
|SigArg  , ListSigArg 

SigReturn ::= 𝜖
| > TypeExpr 

Block ::={ ListStatement  }

ElseClause ::= 𝜖
|else Block 
|else if ValExpr Block ElseClause 

CaseBlock ::={ ListCaseClause  }

CaseClause ::= case PatternExpr  : ListStatement 
|default : ListStatement 

ListCaseClause ::= 𝜖
|CaseClause ListCaseClause 

CatchClause ::=catch ListException Block 

ListCatchClause ::= CatchClause 
|CatchClause ListCatchClause 

Exception ::=TypId 

ListException ::= Exception 
|Exception  , ListException 

PatternExpr ::= # ValId 
|ValId  ˜ PatternExpr 
|ValId 
|Integer 
|+ Integer 
|Integer 
|String 
|( ListSlotPatternExpr  )
|*
|true
|false

SlotPatternExpr ::= ValId  :
|ValId  : PatternExpr 

ListSlotPatternExpr ::= 𝜖
|SlotPatternExpr 
|SlotPatternExpr  , ListSlotPatternExpr 

ValExpr ::= ValExpr1 |ValExpr 
|ValExpr1 

ValExpr1 ::= ValExpr1  xor ValExpr2 
|ValExpr1  eqv ValExpr2 
|ValExpr1  imp ValExpr2 
|ValExpr2 

ValExpr2 ::= ValExpr2  or ValExpr3 
|ValExpr3 

ValExpr3 ::= ValExpr3  and ValExpr4 
|ValExpr4 

ValExpr4 ::= not ValExpr5 
|ValExpr5 

ValExpr5 ::= ValExpr5  = = ValExpr6 
|ValExpr5  ! = ValExpr6 
|ValExpr5  < ValExpr6 
|ValExpr5  < = ValExpr6 
|ValExpr5  > ValExpr6 
|ValExpr5  > = ValExpr6 
|ValExpr5  in ValExpr6 
|ValExpr5  not in ValExpr6 
|ValExpr6 

ValExpr6 ::= ValExpr6 + ValExpr7 
|ValExpr6 ValExpr7 
|ValExpr6 ++ ValExpr7 
|ValExpr6 ||ValExpr7 
|ValExpr6 ValExpr7 
|ValExpr7 

ValExpr7 ::= ValExpr7  * ValExpr8 
|ValExpr7  / ValExpr8 
|ValExpr7  // ValExpr8 
|ValExpr7  % ValExpr8 
|ValExpr7  && ValExpr8 
|ValExpr8 

ValExpr8 ::= ValId  ˜ ValExpr8 
|ValExpr9 

ValExpr9 ::= ValExpr9  ( ListAppArg  )
|ValExpr9  ( ListAppArg  ... )
|ValExpr9  [ ValExpr  ]
|ValExpr9  [ ValExpr  .. ValExpr  ]
|ValExpr9  . ValId 
|ValExpr9  ? ValId 
|ValExpr10 

ValExpr10 ::= + ValExpr10 
|ValExpr10 
|ValExpr11 

ValExpr11 ::= ValId 
|Integer 
|String 
|false
|true
|!! ValId  ( ListValExpr  )
|[ ListValExpr  ]
|{ ListValExpr  }
|{ : }
|{ ListMapPair  }
|# ValId 
|( ListRecPair  )
|#( ValExpr  )
|func ( ListSigArg  ) SigReturn Block 
|( ValExpr  )

ListValExpr ::= 𝜖
|ValExpr 
|ValExpr  , ListValExpr 

AppArg ::= ValExpr 
|ValId  : ValExpr 
|ValId  :
|TypId  : TypeExpr 

ListAppArg ::= 𝜖
|AppArg 
|AppArg  , ListAppArg 

TypeParam ::=TypId  : TypeExpr 

ListTypeParam ::= 𝜖
|TypeParam 
|TypeParam  , ListTypeParam 

MapPair ::=ValExpr  : ValExpr 

ListMapPair ::= MapPair 
|MapPair  , ListMapPair 

RecPair ::= ValId  :
|ValId  : ValExpr 

ListRecPair ::= 𝜖
|RecPair 
|RecPair  , ListRecPair 

TypeExpr ::= Func ( ListSigArg  ) > TypeExpr1 
|TypeExpr1 

TypeExpr1 ::= TypeExpr1 |TypeExpr2 
|TypeExpr2 

TypeExpr2 ::= ValId  ˜ TypeExpr2 
|TypeExpr3 

TypeExpr3 ::= [ TypeExpr  ]
|{ TypeExpr  }
|{ TypeExpr  : TypeExpr  }
|( ListRecParam  )
|TypeExpr4 

TypeExpr4 ::= # ValId 
|TypId  [ ListTypeParam  ]
|TypId 
|!Unspec
|( TypeExpr  )

RecParam ::=ValId  : TypeExpr 

ListRecParam ::= 𝜖
|RecParam 
|RecParam  , ListRecParam 

TypeLhsExpr ::= TypId 
|TypId  [ ListTypId  ]

LetLhsExpr ::= ValId  : TypeExpr 
|ValId ListLensExpr 
|( ListDestructurePhrase  )

LensExpr ::= ? ValId 
|. ValId 
|[ ValExpr  ]
|[ ValExpr  .. ValExpr  ]

ListLensExpr ::= 𝜖
|LensExpr ListLensExpr 

DestructurePhrase ::= ValId 
|ValId  : ValId ListLensExpr 
|ValId  : ( ListDestructurePhrase  )

ListDestructurePhrase ::= 𝜖
|DestructurePhrase 
|DestructurePhrase  , ListDestructurePhrase 

AssignOp ::= : =
| =

AugAssignOp ::= : =
| =
|+ =
| =
|* =
|/ =
|// =
|% =
|++ =
||| =
|&& =
| =

ListTypId ::= TypId 
|TypId  , ListTypId 

ModName ::=ValId 

ListModName ::= ModName 
|ModName  . ListModName 

PragmaWord ::=ValId 

GenName ::=TypId 

ListGenName ::= GenName 
|GenName  , ListGenName