@weborigami/language 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -12,8 +12,8 @@
     "yaml": "2.5.1"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.0",
-    "@weborigami/types": "0.2.0",
+    "@weborigami/async-tree": "0.2.2",
+    "@weborigami/types": "0.2.2",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/origami.pegjs

@@ -16,7 +16,7 @@ import {
   annotate,
   downgradeReference,
   makeArray,
-  makeBinaryOperatorChain,
+  makeBinaryOperation,
   makeCall,
   makeDeferredArguments,
   makeObject,
@@ -24,7 +24,7 @@ import {
   makeProperty,
   makeReference,
   makeTemplate,
-  makeUnaryOperatorCall
+  makeUnaryOperation
 } from "./parserHelpers.js";
 
 }}
@@ -35,6 +35,15 @@ __
     return null;
   }
 
+additiveExpression
+  = head:multiplicativeExpression tail:(__ @additiveOperator __ @multiplicativeExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+additiveOperator
+  = "+"
+  / "-"
+
 arguments "function arguments"
   = parenthesesArguments
   / pathArguments
@@ -52,22 +61,51 @@ arrayEntries
     }
 
 arrayEntry
-  = spread
+  = spreadElement
   / pipelineExpression
+  // JavaScript treats a missing value as `undefined`
+  / __ !"]" {
+      return annotate([ops.literal, undefined], location());
+    }
 
 arrowFunction
   = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipelineExpression {
       return annotate([ops.lambda, parameters ?? [], pipeline], location());
     }
+  / identifier:identifier __ doubleArrow __ pipeline:pipelineExpression {
+      return annotate([ops.lambda, [identifier], pipeline], location());
+    }
   / conditionalExpression
 
+bitwiseAndExpression
+  = head:equalityExpression tail:(__ @bitwiseAndOperator __ @equalityExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+bitwiseAndOperator
+  = @"&" !"&"
+
+bitwiseOrExpression
+  = head:bitwiseXorExpression tail:(__ @bitwiseOrOperator __ @bitwiseXorExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+bitwiseOrOperator
+  = @"|" !"|"
+
+bitwiseXorExpression
+  = head:bitwiseAndExpression tail:(__ @bitwiseXorOperator __ @bitwiseAndExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+bitwiseXorOperator
+  = "^"
+
 // A function call: `fn(arg)`, possibly part of a chain of function calls, like
 // `fn(arg1)(arg2)(arg3)`.
 callExpression "function call"
   = head:protocolExpression tail:arguments* {
-      return tail.length === 0
-        ? head
-        : annotate(tail.reduce(makeCall, head), location());
+      return annotate(tail.reduce(makeCall, head), location());
     }
 
 // Required closing curly brace. We use this for the `object` term: if the
@@ -75,7 +113,7 @@ callExpression "function call"
 closingBrace
   = "}"
   / .? {
-      error("Expected right curly brace");
+      error(`An object ended without a closing brace, or contained something that wasn't expected.\nThe top level of an object can only contain definitions ("a: b" or "a = b") or spreads ("...a").`);
     }
 
 // Required closing bracket
@@ -94,24 +132,35 @@ closingParenthesis
       error("Expected right parenthesis");
     }
 
+// A comma-separated list of expressions: `x, y, z`
+commaExpression
+  // The commas are required, but the list can have a single item.
+  = list:pipelineExpression|1.., __ "," __ | {
+      return list.length === 1
+        ? list[0]
+        : annotate([ops.comma, ...list], location());
+    }
+
 // A single line comment
 comment "comment"
   = multiLineComment
   / singleLineComment
 
 conditionalExpression
-  = condition:logicalOrExpression __
-    "?" __ truthy:pipelineExpression __
-    ":" __ falsy:pipelineExpression
+  = condition:logicalOrExpression tail:(__
+    "?" __ @pipelineExpression __
+    ":" __ @pipelineExpression)?
     {
+      if (!tail) {
+        return condition;
+      }
       return annotate([
         ops.conditional,
         downgradeReference(condition),
-        [ops.lambda, [], downgradeReference(truthy)],
-        [ops.lambda, [], downgradeReference(falsy)]
+        [ops.lambda, [], downgradeReference(tail[0])],
+        [ops.lambda, [], downgradeReference(tail[1])]
       ], location());
     }
-  / logicalOrExpression
   
 digits
   = @[0-9]+
@@ -129,10 +178,8 @@ doubleQuoteStringChar
 ellipsis = "..." / "…" // Unicode ellipsis
 
 equalityExpression
-  = head:unaryExpression tail:(__ @equalityOperator __ @unaryExpression)* {
-      return tail.length === 0
-        ? head
-        : annotate(makeBinaryOperatorChain(head, tail), location());
+  = head:relationalExpression tail:(__ @equalityOperator __ @relationalExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
     }
 
 equalityOperator
@@ -151,12 +198,17 @@ escapedChar "backslash-escaped character"
   / "\\v" { return "\v"; }
   / "\\" @.
 
+exponentiationExpression
+  = left:unaryExpression right:(__ "**" __ @exponentiationExpression)? {
+      return right ? annotate([ops.exponentiation, left, right], location()) : left;
+    }
+
 // A top-level expression, possibly with leading/trailing whitespace
 expression
-  = __ @pipelineExpression __
+  = __ @commaExpression __
 
 floatLiteral "floating-point number"
-  = sign? digits? "." digits {
+  = digits? "." digits {
       return annotate([ops.literal, parseFloat(text())], location());
     }
 
@@ -195,7 +247,7 @@ identifier "identifier"
   = chars:identifierChar+ { return chars.join(""); }
 
 identifierChar
-  = [^(){}\[\]<>\?!&\|\-=,/:\`"'«»\\ →⇒\t\n\r] // No unescaped whitespace or special chars
+  = [^(){}\[\]<>\?!\|\-=,/:\`"'«»\\→⇒… \t\n\r] // No unescaped whitespace or special chars
   / @'-' !'>' // Accept a hyphen but not in a single arrow combination
   / escapedChar
 
@@ -220,7 +272,7 @@ inlineSpace
   = [ \t]
 
 integerLiteral "integer"
-  = sign? digits {
+  = digits {
       return annotate([ops.literal, parseInt(text())], location());
     }
     
@@ -235,7 +287,7 @@ literal
   / stringLiteral
 
 logicalAndExpression
-  = head:equalityExpression tail:(__ "&&" __ @equalityExpression)* {
+  = head:bitwiseOrExpression tail:(__ "&&" __ @bitwiseOrExpression)* {
       return tail.length === 0
         ? head
         : annotate(
@@ -257,6 +309,16 @@ logicalOrExpression
 multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
+multiplicativeExpression
+  = head:exponentiationExpression tail:(__ @multiplicativeOperator __ @exponentiationExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+multiplicativeOperator
+  = "*"
+  / "/"
+  / "%"
+
 // A namespace reference is a string of letters only, followed by a colon.
 // For the time being, we also allow a leading `@`, which is deprecated.
 namespace
@@ -297,7 +359,7 @@ objectEntries
     }
 
 objectEntry
-  = spread
+  = spreadElement
   / objectProperty
   / objectGetter
   / objectShorthandProperty
@@ -382,7 +444,10 @@ pathSegmentChar
 // functions to it.
 pipelineExpression
   = head:shorthandFunction tail:(__ singleArrow __ @shorthandFunction)* {
-      return tail.reduce(makePipeline, downgradeReference(head));
+      return annotate(
+        tail.reduce(makePipeline, downgradeReference(head)),
+        location()
+      );
     }
 
 primary
@@ -419,6 +484,17 @@ reference
   / namespace
   / scopeReference
 
+relationalExpression
+  = head:shiftExpression tail:(__ @relationalOperator __ @shiftExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+relationalOperator
+  = "<="
+  / "<"
+  / ">="
+  / ">"
+
 // A top-level folder below the root: `/foo`
 // or the root folder itself: `/`
 rootDirectory
@@ -449,6 +525,16 @@ slashFollows
 shebang
   = "#!" [^\n\r]* { return null; }
 
+shiftExpression
+  = head:additiveExpression tail:(__ @shiftOperator __ @additiveExpression)* {
+      return annotate(tail.reduce(makeBinaryOperation, head), location());
+    }
+
+shiftOperator
+  = "<<"
+  / ">>>"
+  / ">>"
+
 // A shorthand lambda expression: `=foo(_)`
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
@@ -457,9 +543,6 @@ shorthandFunction "lambda function"
     }
   / implicitParenthesesCallExpression
 
-sign
-  = [+\-]
-
 singleArrow
   = "→"
   / "->"
@@ -475,8 +558,8 @@ singleQuoteString "single quote string"
 singleQuoteStringChar
   = !("'" / newLine) @textChar
 
-spread
-  = ellipsis __ value:conditionalExpression {
+spreadElement
+  = ellipsis __ value:pipelineExpression {
       return annotate([ops.spread, value], location());
     }
 
@@ -539,12 +622,15 @@ textChar
 // A unary prefix operator: `!x`
 unaryExpression
   = operator:unaryOperator __ expression:unaryExpression {
-      return annotate(makeUnaryOperatorCall(operator, expression), location());
+      return annotate(makeUnaryOperation(operator, expression), location());
     }
   / callExpression
 
 unaryOperator
   = "!"
+  / "+"
+  / "-"
+  / "~"
 
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __