GRAMMAR.txt

// Below describes the entire implemented grammar of Opal
// I believe that parser is LL(2) because it needs to look
//  ahead to make some decisions
// Although the parser itself is handwritten, this is the
//  syntax that the following grammar adheres to:
//   - "quoted" or UPPERCASE strings represent terminals
//      while unquoted strings represent non-terminals
//   - line breaks seperate rules instead of an explicit
//      operator denoting "or"
//   - [ X ] means parse X zero or one times
//   - { X } means parse X zero or more times
//   - X Y   means parse X and then Y


// SYNTAX: toplevel
language:
	{toplevel}

toplevel:
	"module" ID
	"use" ID
	["pub"] funcDecl
	["pub"] typeDecl
	["pub"] ifaceDecl
	implDecl

// SYNTAX: misc.
name:
	ID ["::" ID]
var:
	ID ":" type
varOpt:
	ID [":" type]

// SYNTAX: declarations
funcDecl:
	"func" ID "(" [var {"," var}] ")" funcBody
funcBody:
	blockExp
	"extern" "(" STRING ")" STRING "->" type

typeDecl:
	"type" ID [typeParams] typeBody
typeParams:
	"[" [POLYID {"," POLYID}] "]"
typeBody:
	"{" [var {"," var}] "}"
	"extern" "true"
	"extern" "false"
	"=" enumFunc {"or" enumFunc}
enumFunc:
	ID "(" [type {"," type}] ")"

ifaceDecl:
	"iface" [POLYID ":"] ID [typeParams] ifaceBody
ifaceBody:
	"{" {ifaceFunc} "}"
ifaceFunc:
	"fn" ID "(" [type {"," type}] ")" "->" type

implDecl:
	"impl" [ID ":"] type implBody
implBody:
	"{" {funcDecl} "}"

// SYNTAX: types
type:
	name [typeArgs]
	POLYID [typeIfaces]
	funcType
	tupleType
typeArgs:
	"[" type {"," type} "]"
typeIfaces:
	"(" type {"," type} ")"
funcType:
	"fn" "(" [type {"," type}] ")" "->" type
tupleType:
	"(" type {"," type} ")"

// SYNTAX: expressions
opControl:
	"|>"
	">|"
	"|<"
	"<|"
	">>"
	"<<"
opLazy:
	"and"
	"or"
opCmp:
	"<"
	"<="
	"=="
	"!="
	">="
	">"
opCons:
	"$"
opAdd:
	"+"
	"-"
opMul:
	"*"
	"/"
	"%"
opPow:
	"^"
opUnary:
	"-"
	"not"

exp:
	expLazy {opControl expLazy}
expLazy:
	expCmp {opLazy expCmp}
expCmp:
	expCons {opCmp expCons}
expCons:
	expAdd [opCons expCons]
expAdd:
	expMul {opAdd expMul}
expMul:
	expPow {opMul term}
expPow:
	term [opPow expPow]

term:
	opUnary term
	prefixTerm {suffix} [typeHint]

prefixTerm:
	name
	constant
	tupleExp
	fieldExp
	condExp
	objectExp
	lambdaExp
	blockExp
	matchExp

suffix:
	callSuffix
	fieldSuffix
	propertySuffix
	sliceSuffix
	lambdaSuffix
callSuffix:
	"(" [exp {"," exp}] ")"
fieldSuffix:
	"." ID
propertySuffix:
	"." "(" ID ")"
sliceSuffix:
	"[" "," exp "]"
	"[" exp "," exp "]"
	"[" exp "," "]"
	"[" exp "]"
typeHint:
	":" type

constant:
	["-"] numberConstant
	STRING
	CHAR
	"true"
	"false"
numberConstant:
	INT
	REAL
	LONG

tupleExp:
	"(" exp {"," exp} ")"
fieldExp:
	"." ID ["::" type]
condExp:
	"if" exp blockExp elseExp
elseExp:
	"else" condExp
	"else" blockExp

objectExp:
	"new" type objectInits
objectInits:
	"{" [init {"," init}] "}"
init:
	ID "=" exp

lambdaExp:
	"fn" "(" [varOpt {"," varOpt}] ")" blockExp
lambdaSuffix:
	"|" [varOpt {"," varOpt}] "|" blockExp

// SYNTAX: statements
blockExp:
	"{" {stmt} [finalStmt] "}"

stmt:
	";"
	condStmt
	whileLoop
	letDecl
	exp [assignment]

assignment:
	"=" exp
condStmt:
	"if" exp blockExp [elseStmt]
elseStmt:
	"else" condStmt
	"else" blockExp
whileLoop:
	"while" exp blockExp
letDecl:
	"let" pat "=" exp

finalStmt:
	"return" [exp]

// SYNTAX: patterns
matchExp:
	"match" exp matchBody
matchBody:
	"{" {matchCase} "}"
matchCase:
	pat "->" exp
	pat blockExp

pat:
	prefixPat ["$" pat]
prefixPat:
	constant
	ID
	enumPat
	tuplePat
	listPat
enumPat:
	name "(" [pat {"," pat}] ")"
tuplPat:
	"(" [pat {"," pat}] ")"
listPat:
	"[" [pat {"," pat}] "]"