Download The Grace Programming Language Draft Specification Version 0.5

38
B
Revision 2110 committed on 17-06-2015 at 16:56 by black
Grammar
// top level
def program = rule {codeSequence ~ rep(ws) ~ end}
def codeSequence = rule { repdel((declaration | statement), semicolon) }
def innerCodeSequence = rule { repdel((innerDeclaration | statement), semicolon) }
// declarations
def declaration = rule { varDeclaration | defDeclaration | classDeclaration |
typeDeclaration | methodDeclaration }
def innerDeclaration = rule { varDeclaration | defDeclaration | classDeclaration |
typeDeclaration }
def varDeclaration = rule { varId ~ identifier ~ opt(colon ~ typeExpression) ~
opt(assign ~ expression) }
def defDeclaration = rule { defId ~ identifier ~ opt(colon ~ typeExpression) ~
equals ~ expression }
def methodDeclaration = rule { methodId ~ methodHeader ~ methodReturnType ~ whereClause ~
lBrace ~ innerCodeSequence ~ rBrace }
def classDeclaration = rule { classId ~ identifier ~ dot ~ classHeader ~ methodReturnType ~ whereClause ~
lBrace ~ inheritsClause ~ codeSequence ~ rBrace }
//def oldClassDeclaration = rule { classId ~ identifier ~ lBrace ~
// opt(genericFormals ~ blockFormals ~ arrow) ~ codeSequence ~ rBrace }
//warning: order here is significant!
def methodHeader = rule { accessingAssignmentMethodHeader | accessingMethodHeader |
assignmentMethodHeader |
methodWithArgsHeader | unaryMethodHeader | operatorMethodHeader |
prefixMethodHeader }
def classHeader = rule { methodWithArgsHeader | unaryMethodHeader }
def inheritsClause = rule { opt( inheritsId ~ expression ~ semicolon ) }
def unaryMethodHeader = rule { identifier ~ genericFormals }
def methodWithArgsHeader = rule { firstArgumentHeader ~ repsep(argumentHeader,opt(ws)) }
def firstArgumentHeader = rule { identifier ~ genericFormals ~ methodFormals }
def argumentHeader = rule { identifier ~ methodFormals }
def operatorMethodHeader = rule { otherOp ~ oneMethodFormal }
def prefixMethodHeader = rule { opt(ws) ~ token("prefix") ~ otherOp }
// forbid space after prefix?
def assignmentMethodHeader = rule { identifier ~ assign ~ oneMethodFormal }
def accessingMethodHeader = rule { lrBrack ~ genericFormals ~ methodFormals }
def accessingAssignmentMethodHeader = rule { lrBrack ~ assign ~ genericFormals ~ methodFormals }
def methodReturnType = rule { opt(arrow ~ nonEmptyTypeExpression ) }
def methodFormals = rule { lParen ~ rep1sep( identifier ~ opt(colon ~ typeExpression), comma) ~ rParen}
def oneMethodFormal = rule { lParen ~ identifier ~ opt(colon ~ typeExpression) ~ rParen}
def blockFormals = rule { repsep( identifier ~ opt(colon ~ typeExpression), comma) }
def matchBinding = rule{ (identifier | literal | parenExpression) ~
opt(colon ~ nonEmptyTypeExpression ~ opt(matchingBlockTail)) }