feat(language): numeric expressions

3 files changed, 70 insertions, 34 deletions

diff --git a/subprojects/frontend/src/language/indentation.ts b/subprojects/frontend/src/language/indentation.ts
index b49d6563..a0f7032d 100644
--- a/subprojects/frontend/src/language/indentation.ts
+++ b/subprojects/frontend/src/language/indentation.ts
@@ -78,7 +78,7 @@ export function indentDeclaration(context: TreeIndentContext): number {
 
 export function indentPredicateOrRule(context: TreeIndentContext): number {
   const clauseIndent = indentDeclarationStrategy(context, 1);
-  if (/^\s+(?:==>|[;.])/.exec(context.textAfter) !== null) {
+  if (/^\s+(?:->|==>|[;.])/.exec(context.textAfter) !== null) {
     return clauseIndent - context.unit;
   }
   return clauseIndent;
diff --git a/subprojects/frontend/src/language/problem.grammar b/subprojects/frontend/src/language/problem.grammar
index d630b9c4..4235c433 100644
--- a/subprojects/frontend/src/language/problem.grammar
+++ b/subprojects/frontend/src/language/problem.grammar
@@ -2,56 +2,69 @@
 
 @external prop implicitCompletion from './props'
 
+@precedence {
+  containment @cut,
+  prefix,
+  exponential @right,
+  multiplicative @left,
+  additive @left,
+  comparison @left
+}
+
 @top Problem { statement* }
 
 statement {
   ProblemDeclaration {
-    ckw<"problem"> QualifiedName "."
+    kw<"problem"> QualifiedName "."
   } |
   ClassDefinition {
-    ckw<"abstract">? ckw<"class"> RelationName
-    (ckw<"extends"> sep<",", RelationName>)?
+    kw<"abstract">? kw<"class"> RelationName
+    (kw<"extends"> sep<",", RelationName>)?
     (ClassBody {  "{" ReferenceDeclaration* "}" } | ".")
   } |
   EnumDefinition {
-    ckw<"enum"> RelationName
+    kw<"enum"> RelationName
     (EnumBody { "{" sep<",", IndividualNodeName> "}" } | ".")
   } |
   PredicateDefinition {
     (
-      (ckw<"error"> | ckw<"contained"> | ckw<"containment">) ckw<"pred">? |
-      ckw<"pred">
+      (kw<"error"> | ckw<"contained"> | kw<"containment">)? kw<"pred"> |
+      kw<"error">
     )
     RelationName ParameterList<Parameter>?
-    PredicateBody { ("<->" sep<OrOp, Conjunction>)?  "." }
+    PredicateBody { ("<->" sep<OrOp, Conjunction>)? "." }
+  } |
+  FunctionDefinition {
+    RelationName RelationName ParameterList<Parameter>?
+    FunctionBody { ("=" sep<OrOp, Case>)? "." }
   } |
   //RuleDefinition {
-  //  ckw<"rule">
+  //  kw<"rule">
   //  RuleName ParameterList<Parameter>?
   //  RuleBody { ":" sep<OrOp, Conjunction> "==>" sep<OrOp, Consequent> "." }
   //} |
   Assertion {
-    ckw<"default">? (NotOp | UnknownOp)? RelationName
+    kw<"default">? (NotOp | UnknownOp)? RelationName
     ParameterList<AssertionArgument> (":" LogicValue)? "."
   } |
   NodeValueAssertion {
     QualifiedName ":" Constant "."
   } |
   IndividualDeclaration {
-    ckw<"indiv"> sep<",", IndividualNodeName> "."
+    kw<"individual"> sep<",", IndividualNodeName> "."
   } |
   ScopeDeclaration {
-    ckw<"scope"> sep<",", ScopeElement> "."
+    kw<"scope"> sep<",", ScopeElement> "."
   }
 }
 
 ReferenceDeclaration {
   (
-    ExplicitContainmentReference[@dynamicPrecedence=1] {
-      (ckw<"refers"> | ckw<"contains"> | ckw<"container">) RelationName ~containment
+    ExplicitContainmentReference {
+      !containment (kw<"refers"> | ckw<"contains"> | kw<"container">) RelationName
     } |
     ImplicitContainmentReference {
-      RelationName ~containment
+      RelationName
     }
   )
   ("[" Multiplicity? "]")?
@@ -62,50 +75,68 @@ ReferenceDeclaration {
 
 Parameter { Modality? RelationName? VariableName }
 
-Conjunction { ("," | Literal)+ }
+Conjunction { ("," | Expr)+ }
+
+Case { Conjunction ("->" Expr)? }
 
 OrOp { ";" }
 
-Literal {
-  Modality? (NotOp | ckw<"count">)? Modality? Atom
-  ((":=" | "<:") LogicValue | ComparisonOp int)?
+Expr {
+  UnaryExpr | BinaryExpr | Aggregation | VariableName | Atom | Constant | "(" Expr ")"
+}
+
+BinaryExpr[@dynamicPrecedence=1] {
+  Expr !comparison ComparisonOp Expr |
+  Expr !additive ("+" | "-") Expr |
+  Expr !multiplicative (StarMult | Divide) Expr |
+  Expr !exponential "**" Expr
+}
+
+UnaryExpr {
+  !prefix ("+" | "-" | "!" | "#" | Modality) Expr
+}
+
+Aggregation {
+  AggregationOp "{" Expr "|" Expr "}"
 }
 
-Atom { RelationName "+"? ParameterList<Argument> }
+Atom { RelationName "+"? ParameterList<Expr> }
 
 //Consequent { ("," | Action)+ }
 
 //Action {
 //   ckw<"new"> VariableName ("<:" VariableName)? |
-//   ckw<"delete"> VariableName |
+//   kw<"delete"> VariableName |
 //   Literal
 //}
 
-Argument { VariableName | Constant }
-
 AssertionArgument { NodeName | StarArgument | Constant }
 
 Constant { Real | String }
 
 LogicValue {
-  ckw<"true"> | ckw<"false"> | ckw<"unknown"> | ckw<"error">
+  ckw<"true"> | ckw<"false"> | kw<"unknown"> | kw<"error">
 }
 
 Modality {
-  ckw<"must"> | ckw<"may"> | ckw<"current">
+  kw<"must"> | kw<"may"> | kw<"current">
+}
+
+AggregationOp {
+  ckw<"sum"> | ckw<"prod"> | ckw<"min"> | ckw<"max">
 }
 
 ScopeElement { RelationName ("=" | "+=") Multiplicity }
 
 Multiplicity { (IntMult "..")? (IntMult | StarMult)}
 
-RelationName { QualifiedName }
+RelationName { QualifiedName ~name }
 
 //RuleName { QualifiedName }
 
 IndividualNodeName { QualifiedName }
 
-VariableName { QualifiedName }
+VariableName[@dynamicPrecedence=10] { QualifiedName ~name }
 
 NodeName { QualifiedName }
 
@@ -134,7 +165,9 @@ sep1<separator, content> { content (separator content)* }
 
   blockCommentAfterStar { "/" | "*" blockCommentAfterStar | ![/*] blockCommentRest }
 
-  @precedence { BlockComment, LineComment }
+  Divide { "/" }
+
+  @precedence { BlockComment, LineComment, Divide }
 
   identifier { $[A-Za-z_] $[a-zA-Z0-9_]* }
 
@@ -144,7 +177,7 @@ sep1<separator, content> { content (separator content)* }
 
   StarMult { "*" }
 
-  Real { "-"? (exponential | int ("." (int | exponential))?) }
+  Real { (exponential | int ("." (int | exponential))?) }
 
   exponential { int ("e" | "E") ("+" | "-")? int }
 
@@ -161,5 +194,5 @@ sep1<separator, content> { content (separator content)* }
 
   StarArgument { "*" }
 
-  "{" "}" "(" ")" "[" "]" "." ".." "," ":" "<->" "~>"
+  "{" "}" "(" ")" "[" "]" "." ".." "," ":" "->" "<->" "+" "-" "**" "=" "+="
 }
diff --git a/subprojects/frontend/src/language/problemLanguageSupport.ts b/subprojects/frontend/src/language/problemLanguageSupport.ts
index a96b5402..cde8b157 100644
--- a/subprojects/frontend/src/language/problemLanguageSupport.ts
+++ b/subprojects/frontend/src/language/problemLanguageSupport.ts
@@ -21,11 +21,12 @@ const parserWithMetadata = parser.configure({
     styleTags({
       LineComment: t.lineComment,
       BlockComment: t.blockComment,
-      'problem class enum pred indiv scope': t.definitionKeyword,
+      'problem class enum pred individual scope': t.definitionKeyword,
       'abstract extends refers contains container opposite': t.modifier,
       'default error contained containment': t.modifier,
       'true false unknown error': t.operatorKeyword,
-      'may must current count': t.operatorKeyword,
+      'may must current': t.operatorKeyword,
+      'sum prod min max': t.operatorKeyword,
       // 'new delete': t.keyword,
       NotOp: t.operator,
       UnknownOp: t.operator,
@@ -42,13 +43,14 @@ const parserWithMetadata = parser.configure({
       '( )': t.paren,
       '[ ]': t.squareBracket,
       '. .. , :': t.separator,
-      '<-> ==>': t.definitionOperator,
+      '<-> = -> ==>': t.definitionOperator,
     }),
     indentNodeProp.add({
       ProblemDeclaration: indentDeclaration,
       UniqueDeclaration: indentDeclaration,
       ScopeDeclaration: indentDeclaration,
       PredicateBody: indentPredicateOrRule,
+      FunctionBody: indentPredicateOrRule,
       // RuleBody: indentPredicateOrRule,
       BlockComment: indentBlockComment,
     }),
@@ -57,6 +59,7 @@ const parserWithMetadata = parser.configure({
       EnumBody: foldInside,
       ParameterList: foldInside,
       PredicateBody: foldInside,
+      FunctionBody: foldInside,
       // RuleBody: foldInside,
       Conjunction: foldConjunction,
       // Consequent: foldWholeNode,
@@ -77,7 +80,7 @@ const problemLanguage = LRLanguage.define({
       },
       line: '%',
     },
-    indentOnInput: /^\s*(?:\{|\}|\(|\)|;|\.)$/,
+    indentOnInput: /^\s*(?:\{|\}|\(|\)|->|;|\.)$/,
   },
 });