Begin syntax revision

Cargo.lock

@@ -459,7 +459,7 @@ dependencies = [
 
 [[package]]
 name = "dust-lang"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "ansi_term",
  "async-std",

examples/clue_solver.ds

@@ -10,7 +10,7 @@ take_turn = function <current_room opponent_card> {
 
 remove_card = function <opponent_card> {
 	for card_list in cards {
-		removed = remove card in card_list {
+		removed = remove card from card_list {
 			card == opponent_card
 		}
 	}
@@ -21,16 +21,16 @@ remove_card = function <opponent_card> {
 }
 
 make_guess = function <current_room> {
-	if ((length suspects) == 1)
+	if (length suspects) == 1
-		&& ((length rooms) == 1)
+		&& (length rooms) == 1
-		&& ((length weapons) == 1)
+		&& (length weapons) == 1
 	{
 		(output 'It was '
-			+ suspects.{0}
+			+ suspects:0
 			+ ' in the '
-			+ rooms.{0} 
+			+ rooms:0 
 			+ ' with the '
-			+ weapons.{0}
+			+ weapons:0
 			+ '!')
 	} else {
 		(output 'I accuse '
@@ -42,3 +42,5 @@ make_guess = function <current_room> {
 			+ '!')
 	}
 }
+
+(make_guess 'Library')

examples/for_loop.ds

@@ -1,6 +1,6 @@
 list = [1 2 3]
 
-async for i in list {
+for i in list {
 	i += 1
 	(output i)
 }

examples/scope.ds

@@ -1,60 +0,0 @@
-# Function
-x = "bar"
-
-func = function <> { 
-	x = "foo"
-	x
-}
-
-assert_equal("foo", (func))
-assert_equal("bar", x)
-
-# For Loop
-x = 42
-
-for number in [1 2 3] {
-	x += number
-}
-
-assert_equal(48, x)
-
-# Async Loops
-
-## Transform Loop
-
-x = 42
-y = [1 2 3]
-
-transform number in y {
-	number += x
-	x = 1000
-}
- 
-assert_equal([43, 44, 45], y)
-assert_equal(42, x)
-
-## Filter Loop
-
-x = 42
-y = [1 2 3]
-
-transform number in y {
-	number += x
-	x = 1000
-}
- 
-assert_equal([43, 44, 45], y)
-assert_equal(42, x)
-
-## Filter Loop
-
-x = 42
-y = [1 2 3]
-
-filter number in y {
-	number += x
-	x = 1000
-}
- 
-assert_equal([43, 44, 45], y)
-assert_equal(42, x)

examples/transform_loop.ds

@@ -1,5 +1,5 @@
 data = (from_json (read "examples/assets/jq_data.json"))
 
 transform item in data {
-	item.{commit}.{committer}.{name}
+	item:commit:committer:name
 }

src/abstract_tree/filter.rs

@@ -6,41 +6,58 @@ use crate::{AbstractTree, Error, Expression, Identifier, Item, List, Map, Result
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Filter {
-    identifier: Identifier,
+    count: Option<Expression>,
-    expression: Expression,
+    item_id: Identifier,
-    item: Item,
+    collection: Expression,
+    predicate: Item,
 }
 
 impl AbstractTree for Filter {
     fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
-        let identifier_node = node.child(1).unwrap();
+        let count = match node.child_by_field_name("count") {
-        let identifier = Identifier::from_syntax_node(source, identifier_node)?;
+            Some(node) => Some(Expression::from_syntax_node(source, node)?),
+            None => None,
+        };
 
-        let expression_node = node.child(3).unwrap();
+        let item_id_node = node.child(1).unwrap();
-        let expression = Expression::from_syntax_node(source, expression_node)?;
+        let item_id = Identifier::from_syntax_node(source, item_id_node)?;
 
-        let item_node = node.child(5).unwrap();
+        let collection_node = node.child(3).unwrap();
-        let item = Item::from_syntax_node(source, item_node)?;
+        let collection = Expression::from_syntax_node(source, collection_node)?;
+
+        let predicate_node = node.child(5).unwrap();
+        let predicate = Item::from_syntax_node(source, predicate_node)?;
 
         Ok(Filter {
-            identifier,
+            count,
-            expression,
+            item_id,
-            item,
+            collection,
+            predicate,
         })
     }
 
     fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
-        let value = self.expression.run(source, context)?;
+        let value = self.collection.run(source, context)?;
         let values = value.as_list()?.items();
-        let key = self.identifier.inner();
+        let key = self.item_id.inner();
         let new_values = List::new();
+        let count = match &self.count {
+            Some(expression) => Some(expression.run(source, context)?.as_integer()? as usize),
+            None => None,
+        };
 
         values.par_iter().try_for_each(|value| {
+            if let Some(max) = count {
+                if new_values.items().len() == max {
+                    return Ok(());
+                }
+            }
+
             let mut context = Map::new();
 
             context.variables_mut().insert(key.clone(), value.clone());
 
-            let should_include = self.item.run(source, &mut context)?.as_boolean()?;
+            let should_include = self.predicate.run(source, &mut context)?.as_boolean()?;
 
             if should_include {
                 new_values.items_mut().push(value.clone());

src/abstract_tree/for.rs

@@ -17,10 +17,9 @@ impl AbstractTree for For {
         let for_node = node.child(0).unwrap();
         let is_async = match for_node.kind() {
             "for" => false,
-            "async for" => true,
             _ => {
                 return Err(Error::UnexpectedSyntaxNode {
-                    expected: "\"for\" or \"async for\"",
+                    expected: "for",
                     actual: for_node.kind(),
                     location: for_node.start_position(),
                     relevant_source: source[for_node.byte_range()].to_string(),

tests/dust_examples.rs

@@ -59,12 +59,6 @@ fn remove_loop() {
     evaluate(&file_contents).unwrap();
 }
 
-#[test]
-fn scope() {
-    let file_contents = read_to_string("examples/scope.ds").unwrap();
-
-    evaluate(&file_contents).unwrap();
-}
 #[test]
 fn table() {
     let file_contents = read_to_string("examples/table.ds").unwrap();

tree-sitter-dust/corpus/async.txt

@@ -10,12 +10,13 @@ async { (output 'Whaddup') }
   (item
     (statement
       (async
+        (item
           (statement
             (expression
               (tool
                 (expression
                   (value
-                  (string))))))))))
+                    (string)))))))))))
 
 ==================
 Complex Async Statements
@@ -23,12 +24,12 @@ Complex Async Statements
 
 async {
   if 1 % 2 == 0 {
-    (output 'true')
+    true
   } else {
-    (output 'false')
+    false
   }
 
-  (output 'foobar')
+  'foobar'
 }
 
 ---
@@ -37,6 +38,7 @@ async {
   (item
     (statement
       (async
+        (item
           (statement
             (if_else
               (if
@@ -55,109 +57,18 @@ async {
                     (expression
                       (value
                         (integer)))))
+                (item
                   (statement
-                (expression
-                  (tool
                     (expression
                       (value
-                        (string)))))))
+                        (boolean))))))
               (else
+                (item
                   (statement
                     (expression
-                  (tool
+                      (value
+                        (boolean))))))))
+          (statement
             (expression
               (value
                 (string)))))))))
-        (statement
-          (expression
-            (tool
-              (expression
-                (value
-                  (string))))))))))
-                    
-==================
-Simple Async Await Statements
-==================
-
-x = async {
-  1
-}
-
-
----
-
-(root
-  (item
-    (statement
-      (assignment
-        (identifier)
-        (assignment_operator)
-        (statement
-          (async
-            (statement
-              (expression
-                (value
-                  (integer))))))))))
-                    
-==================
-Complex Async Await Statements
-==================
-
-x = async {
-  i = 0
-  while i < 5 {
-    (output i)
-    i += 1
-  }
-  (read "examples/assets/faithful.csv")
-}
-
-
----
-
-(root
-  (item
-    (statement
-      (assignment
-        (identifier)
-        (assignment_operator)
-        (statement
-          (async
-            (statement
-              (assignment
-                (identifier)
-                (assignment_operator)
-                (statement
-                  (expression
-                    (value
-                      (integer))))))
-            (statement
-              (while
-                (expression
-                  (logic
-                    (expression
-                      (identifier))
-                    (logic_operator)
-                    (expression
-                      (value
-                        (integer)))))
-                (item
-                  (statement
-                    (expression
-                      (tool
-                        (expression
-                          (identifier)))))
-                  (statement
-                    (assignment
-                      (identifier)
-                      (assignment_operator)
-                      (statement
-                        (expression
-                          (value
-                            (integer)))))))))
-            (statement
-              (expression
-                (tool
-                  (expression
-                    (value
-                      (string))))))))))))

tree-sitter-dust/corpus/control_flow.txt

@@ -14,10 +14,11 @@ if true { "True" }
           (expression
             (value
               (boolean)))
+          (item
             (statement
               (expression
                 (value
-                (string)))))))))
+                  (string))))))))))
 
 ==================
 Complex If
@@ -65,10 +66,11 @@ if (1 == 1) && (2 == 2) && (3 == 3) { "True" }
                       (expression
                         (value
                           (integer)))))))))
+        (item
           (statement
             (expression
               (value
-                (string)))))))))
+                (string))))))))))
 
 ==================
 If Assignment
@@ -90,10 +92,11 @@ x = if true { 1 }
               (expression
                 (value
                   (boolean)))
+              (item
                 (statement
                   (expression
                     (value
-                    (integer)))))))))))
+                      (integer))))))))))))
 
 ==================
 If Else
@@ -111,15 +114,17 @@ if false { "True" } else { "False" }
           (expression
             (value
               (boolean)))
+          (item
             (statement
               (expression
                 (value
-                (string)))))
+                  (string))))))
         (else
+          (item
             (statement
               (expression
                 (value
-                (string)))))))))
+                  (string))))))))))
 
 ==================
 If Else If
@@ -147,10 +152,11 @@ if 1 == 1 {
               (expression
                 (value
                   (integer)))))
+          (item
             (statement
               (expression
                 (value
-                (string)))))
+                  (string))))))
         (else_if
           (expression
             (logic
@@ -161,10 +167,11 @@ if 1 == 1 {
               (expression
                 (value
                   (integer)))))
+          (item
             (statement
               (expression
                 (value
-                (string)))))))))
+                  (string))))))))))
 
 ==================
 If Else Else If Else
@@ -190,18 +197,20 @@ if false {
           (expression
             (value
               (boolean)))
+          (item
             (statement
               (expression
                 (value
-                (string)))))
+                  (string))))))
         (else_if
           (expression
             (value
               (boolean)))
+          (item
             (statement
               (expression
                 (value
-                (string)))))
+                  (string))))))
         (else_if
           (expression
             (logic
@@ -218,12 +227,14 @@ if false {
               (expression
                 (value
                   (integer)))))
+          (item
             (statement
               (expression
                 (value
-                (string)))))
+                  (string))))))
         (else
+          (item
             (statement
               (expression
                 (value
-                (string)))))))))
+                  (string))))))))))

tree-sitter-dust/corpus/for.txt

@@ -33,17 +33,13 @@ for i in [1, 2, 3] {
                   (identifier))))))))))
 
 ==================
-Complex For Loop
+Nested For Loop
 ==================
 
 for list in list_of_lists {
   for item in list {
     (output item)
   }
-
-  if (length list) > 1 {
-    (output "List is long...")
-  }
 }
 
 ---
@@ -66,23 +62,4 @@ for list in list_of_lists {
                   (expression
                     (tool
                       (expression
-                        (identifier))))))))
+                        (identifier)))))))))))))
-          (statement
-            (if_else
-              (if
-                (expression
-                  (logic
-                    (expression
-                      (tool
-                        (expression
-                          (identifier))))
-                    (logic_operator)
-                    (expression
-                      (value
-                        (integer)))))
-                (statement
-                  (expression
-                    (tool
-                      (expression
-                        (value
-                          (string))))))))))))))

tree-sitter-dust/corpus/reduce.txt

@@ -0,0 +1,77 @@
+==================
+Reduce Loop
+==================
+
+reduce i to acc in [1, 2, 3] {
+  acc += i
+}
+
+---
+
+(root
+  (item
+    (statement
+      (reduce
+        (identifier)
+        (identifier)
+        (expression
+          (value
+            (list
+              (expression
+                (value
+                  (integer)))
+              (expression
+                (value
+                  (integer)))
+              (expression
+                (value
+                  (integer))))))
+        (item
+          (statement
+            (assignment
+              (identifier)
+              (assignment_operator)
+              (statement
+                (expression
+                  (identifier))))))))))
+
+==================
+Reduce Loop Assignment
+==================
+
+together = reduce i to acc in ["one", "two", "three"] {
+  acc += i
+}
+
+---
+
+(root
+  (item
+    (statement
+      (assignment
+        (identifier)
+        (assignment_operator)
+        (statement
+          (reduce
+            (identifier)
+            (identifier)
+            (expression
+              (value
+                (list
+                  (expression
+                    (value
+                      (string)))
+                  (expression
+                    (value
+                      (string)))
+                  (expression
+                    (value
+                      (string))))))
+            (item
+              (statement
+                (assignment
+                  (identifier)
+                  (assignment_operator)
+                  (statement
+                    (expression
+                      (identifier))))))))))))

tree-sitter-dust/corpus/remove.txt

@@ -2,7 +2,7 @@
 Remove Loop
 ==================
 
-remove i in [1, 2, 3] {
+remove i from [1, 2, 3] {
   i <= 2
 }
 
@@ -40,7 +40,7 @@ remove i in [1, 2, 3] {
 Remove Loop Assignment
 ==================
 
-removed = remove i in ["one", "two", "three"] {
+removed = remove i from ["one", "two", "three"] {
   i == "two"
 }
 

tree-sitter-dust/grammar.js

@@ -4,24 +4,29 @@ module.exports = grammar({
   word: $ => $.identifier,
 
   rules: {
-    root: $ => repeat1($.item),
+    root: $ => repeat1($.statement),
-
-    item: $ => prec.left(repeat1($.statement)),
 
     statement: $ => prec.left(choice(
-      $.comment,
+      repeat1($._statement_kind),
+      seq('{', $._statement_kind, '}'),
+    // ))
+
+    _statement_kind: $ => prec.left(choice(
       $.assignment,
-      $.expression,
-      $.if_else,
-      $.insert,
-      $.select,
-      $.while,
       $.async,
-      $.for,
+      $.comment,
-      $.transform,
+      $.expression,
       $.filter,
       $.find,
+      $.for,
+      $.if_else,
+      $.insert,
+      $.match,
+      $.reduce,
       $.remove,
+      $.select,
+      $.transform,
+      $.while,
     )),
   
     comment: $ => seq(/[#]+.*/),
@@ -32,13 +37,13 @@ module.exports = grammar({
     ),
 
     _expression_kind: $ => choice(
-      $.value,
+      $.function_call,
       $.identifier,
       $.index,
-      $.math,
       $.logic,
-      $.function_call,
+      $.math,
       $.tool,
+      $.value,
     ),
 
     identifier: $ => /[_a-zA-Z]+[_a-zA-Z0-9]?/,
@@ -54,21 +59,19 @@ module.exports = grammar({
       $.map,
     ),
 
-    _numeric: $ => token(repeat1(
+    integer: $ => prec.left(token(seq(
+      optional('-'),
+      repeat1(
         choice('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')
-    )),
+      ),
+    ))),
 
-    integer: $ => prec.left(seq(
+    float: $ => prec.left(token(seq(
-      optional(token.immediate('-')),
+      optional('-'),
-      $._numeric,
+      repeat1(choice('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')),
-    )),
+      '.',
-
+      repeat1(choice('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')),
-    float: $ => prec.left(seq(
+    ))),
-      optional(token.immediate('-')),
-      $._numeric,
-      token.immediate('.'),
-      $._numeric,
-    )),
 
     string: $ => /("[^"]*?")|('[^']*?')|(`[^`]*?`)/,
 
@@ -85,7 +88,7 @@ module.exports = grammar({
 
     map: $ => seq(
       '{',
-      repeat(seq($.identifier, "=", $.expression)),
+      $.assignment,
       '}',
     ),
 
@@ -103,7 +106,7 @@ module.exports = grammar({
       'function',
       optional(seq('<', repeat(seq($.identifier, optional(','))), '>')),
       '{',
-      $.item,
+      $.statement,
       '}',
     ),
 
@@ -192,11 +195,23 @@ module.exports = grammar({
       ')',
     )),
 
+    match: $ => seq(
+      'match',
+      $.expression,
+      '{',
+      repeat1(seq(
+        $.expression,
+        '=>',
+        $.statement,
+      )),
+      '}',
+    ),
+
     while: $ => seq(
       'while',
       $.expression,
       '{',
-      $.item,
+      $.statement,
       '}',      
     ),
 
@@ -206,7 +221,7 @@ module.exports = grammar({
       'in',
       $.expression,
       '{',
-      $.item,
+      $.statement,
       '}',
     ),
 
@@ -216,17 +231,18 @@ module.exports = grammar({
       'in',
       $.expression,
       '{',
-      $.item,
+      $.statement,
       '}',
     ),
 
     filter: $ => seq(
       'filter',
-      $.identifier,
+      field('count', optional($.expression)),
+      field('statement_id', $.identifier),
       'in',
-      $.expression,
+      field('collection', $.expression),
       '{',
-      $.item,
+      field('predicate', $.statement),
       '}',
     ),
 
@@ -236,17 +252,29 @@ module.exports = grammar({
       'in',
       $.expression,
       '{',
-      $.item,
+      $.statement,
       '}',
     ),
 
     remove: $ => seq(
       'remove',
       $.identifier,
+      'from',
+      $.expression,
+      '{',
+      $.statement,
+      '}',
+    ),
+
+    reduce: $ => seq(
+      'reduce',
+      $.identifier,
+      'to',
+      $.identifier,
       'in',
       $.expression,
       '{',
-      $.item,
+      $.statement,
       '}',
     ),
 
@@ -257,7 +285,7 @@ module.exports = grammar({
       '>',
       'from',
       $.expression,
-      optional(seq('{', $.item, '}')),
+      optional(seq('{', $.statement, '}')),
     )),
 
     insert: $ => prec.right(seq(

tree-sitter-dust/src/grammar.json

@@ -3,22 +3,11 @@
   "word": "identifier",
   "rules": {
     "root": {
-      "type": "REPEAT1",
-      "content": {
-        "type": "SYMBOL",
-        "name": "item"
-      }
-    },
-    "item": {
-      "type": "PREC_LEFT",
-      "value": 0,
-      "content": {
       "type": "REPEAT1",
       "content": {
         "type": "SYMBOL",
         "name": "statement"
       }
-      }
     },
     "statement": {
       "type": "PREC_LEFT",
@@ -27,44 +16,53 @@
         "type": "CHOICE",
         "members": [
           {
+            "type": "REPEAT1",
+            "content": {
               "type": "SYMBOL",
-            "name": "comment"
+              "name": "_statement_kind"
+            }
           },
+          {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "STRING",
+                "value": "{"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "_statement_kind"
+              },
+              {
+                "type": "STRING",
+                "value": "}"
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "_statement_kind": {
+      "type": "PREC_LEFT",
+      "value": 0,
+      "content": {
+        "type": "CHOICE",
+        "members": [
           {
             "type": "SYMBOL",
             "name": "assignment"
           },
-          {
-            "type": "SYMBOL",
-            "name": "expression"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "if_else"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "insert"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "select"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "while"
-          },
           {
             "type": "SYMBOL",
             "name": "async"
           },
           {
             "type": "SYMBOL",
-            "name": "for"
+            "name": "comment"
           },
           {
             "type": "SYMBOL",
-            "name": "transform"
+            "name": "expression"
           },
           {
             "type": "SYMBOL",
@@ -74,9 +72,41 @@
             "type": "SYMBOL",
             "name": "find"
           },
+          {
+            "type": "SYMBOL",
+            "name": "for"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "if_else"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "insert"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "match"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "reduce"
+          },
           {
             "type": "SYMBOL",
             "name": "remove"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "select"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "transform"
+          },
+          {
+            "type": "SYMBOL",
+            "name": "while"
           }
         ]
       }
@@ -121,7 +151,7 @@
       "members": [
         {
           "type": "SYMBOL",
-          "name": "value"
+          "name": "function_call"
         },
         {
           "type": "SYMBOL",
@@ -131,21 +161,21 @@
           "type": "SYMBOL",
           "name": "index"
         },
-        {
-          "type": "SYMBOL",
-          "name": "math"
-        },
         {
           "type": "SYMBOL",
           "name": "logic"
         },
         {
           "type": "SYMBOL",
-          "name": "function_call"
+          "name": "math"
         },
         {
           "type": "SYMBOL",
           "name": "tool"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "value"
         }
       ]
     },
@@ -190,9 +220,27 @@
         }
       ]
     },
-    "_numeric": {
+    "integer": {
+      "type": "PREC_LEFT",
+      "value": 0,
+      "content": {
         "type": "TOKEN",
         "content": {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "CHOICE",
+              "members": [
+                {
+                  "type": "STRING",
+                  "value": "-"
+                },
+                {
+                  "type": "BLANK"
+                }
+              ]
+            },
+            {
               "type": "REPEAT1",
               "content": {
                 "type": "CHOICE",
@@ -240,38 +288,15 @@
                 ]
               }
             }
-    },
-    "integer": {
-      "type": "PREC_LEFT",
-      "value": 0,
-      "content": {
-        "type": "SEQ",
-        "members": [
-          {
-            "type": "CHOICE",
-            "members": [
-              {
-                "type": "IMMEDIATE_TOKEN",
-                "content": {
-                  "type": "STRING",
-                  "value": "-"
-                }
-              },
-              {
-                "type": "BLANK"
-              }
           ]
-          },
-          {
-            "type": "SYMBOL",
-            "name": "_numeric"
         }
-        ]
       }
     },
     "float": {
       "type": "PREC_LEFT",
       "value": 0,
+      "content": {
+        "type": "TOKEN",
         "content": {
           "type": "SEQ",
           "members": [
@@ -279,11 +304,8 @@
               "type": "CHOICE",
               "members": [
                 {
-                "type": "IMMEDIATE_TOKEN",
-                "content": {
                   "type": "STRING",
                   "value": "-"
-                }
                 },
                 {
                   "type": "BLANK"
@@ -291,23 +313,109 @@
               ]
             },
             {
-            "type": "SYMBOL",
+              "type": "REPEAT1",
-            "name": "_numeric"
-          },
-          {
-            "type": "IMMEDIATE_TOKEN",
               "content": {
+                "type": "CHOICE",
+                "members": [
+                  {
                     "type": "STRING",
-              "value": "."
+                    "value": "1"
-            }
                   },
                   {
-            "type": "SYMBOL",
+                    "type": "STRING",
-            "name": "_numeric"
+                    "value": "2"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "3"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "4"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "5"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "6"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "7"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "8"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "9"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "0"
                   }
                 ]
               }
             },
+            {
+              "type": "STRING",
+              "value": "."
+            },
+            {
+              "type": "REPEAT1",
+              "content": {
+                "type": "CHOICE",
+                "members": [
+                  {
+                    "type": "STRING",
+                    "value": "1"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "2"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "3"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "4"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "5"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "6"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "7"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "8"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "9"
+                  },
+                  {
+                    "type": "STRING",
+                    "value": "0"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    },
     "string": {
       "type": "PATTERN",
       "value": "(\"[^\"]*?\")|('[^']*?')|(`[^`]*?`)"
@@ -369,25 +477,9 @@
           "type": "STRING",
           "value": "{"
         },
-        {
-          "type": "REPEAT",
-          "content": {
-            "type": "SEQ",
-            "members": [
         {
           "type": "SYMBOL",
-                "name": "identifier"
+          "name": "assignment"
-              },
-              {
-                "type": "STRING",
-                "value": "="
-              },
-              {
-                "type": "SYMBOL",
-                "name": "expression"
-              }
-            ]
-          }
         },
         {
           "type": "STRING",
@@ -495,7 +587,7 @@
         },
         {
           "type": "SYMBOL",
-          "name": "item"
+          "name": "statement"
         },
         {
           "type": "STRING",
@@ -852,6 +944,47 @@
         ]
       }
     },
+    "match": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "match"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "expression"
+        },
+        {
+          "type": "STRING",
+          "value": "{"
+        },
+        {
+          "type": "REPEAT1",
+          "content": {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "expression"
+              },
+              {
+                "type": "STRING",
+                "value": "=>"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "statement"
+              }
+            ]
+          }
+        },
+        {
+          "type": "STRING",
+          "value": "}"
+        }
+      ]
+    },
     "while": {
       "type": "SEQ",
       "members": [
@@ -869,7 +1002,7 @@
         },
         {
           "type": "SYMBOL",
-          "name": "item"
+          "name": "statement"
         },
         {
           "type": "STRING",
@@ -902,7 +1035,7 @@
         },
         {
           "type": "SYMBOL",
-          "name": "item"
+          "name": "statement"
         },
         {
           "type": "STRING",
@@ -935,7 +1068,7 @@
         },
         {
           "type": "SYMBOL",
-          "name": "item"
+          "name": "statement"
         },
         {
           "type": "STRING",
@@ -951,24 +1084,52 @@
           "value": "filter"
         },
         {
+          "type": "FIELD",
+          "name": "count",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "expression"
+              },
+              {
+                "type": "BLANK"
+              }
+            ]
+          }
+        },
+        {
+          "type": "FIELD",
+          "name": "statement_id",
+          "content": {
             "type": "SYMBOL",
             "name": "identifier"
+          }
         },
         {
           "type": "STRING",
           "value": "in"
         },
         {
+          "type": "FIELD",
+          "name": "collection",
+          "content": {
             "type": "SYMBOL",
             "name": "expression"
+          }
         },
         {
           "type": "STRING",
           "value": "{"
         },
         {
+          "type": "FIELD",
+          "name": "predicate",
+          "content": {
             "type": "SYMBOL",
-          "name": "item"
+            "name": "statement"
+          }
         },
         {
           "type": "STRING",
@@ -1001,7 +1162,7 @@
         },
         {
           "type": "SYMBOL",
-          "name": "item"
+          "name": "statement"
         },
         {
           "type": "STRING",
@@ -1020,6 +1181,47 @@
           "type": "SYMBOL",
           "name": "identifier"
         },
+        {
+          "type": "STRING",
+          "value": "from"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "expression"
+        },
+        {
+          "type": "STRING",
+          "value": "{"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "statement"
+        },
+        {
+          "type": "STRING",
+          "value": "}"
+        }
+      ]
+    },
+    "reduce": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "reduce"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "identifier"
+        },
+        {
+          "type": "STRING",
+          "value": "to"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "identifier"
+        },
         {
           "type": "STRING",
           "value": "in"
@@ -1034,7 +1236,7 @@
         },
         {
           "type": "SYMBOL",
-          "name": "item"
+          "name": "statement"
         },
         {
           "type": "STRING",
@@ -1104,7 +1306,7 @@
                   },
                   {
                     "type": "SYMBOL",
-                    "name": "item"
+                    "name": "statement"
                   },
                   {
                     "type": "STRING",

tree-sitter-dust/src/node-types.json

@@ -128,24 +128,47 @@
   {
     "type": "filter",
     "named": true,
-    "fields": {},
+    "fields": {
-    "children": {
+      "collection": {
-      "multiple": true,
+        "multiple": false,
         "required": true,
         "types": [
           {
             "type": "expression",
             "named": true
+          }
+        ]
       },
+      "count": {
+        "multiple": false,
+        "required": false,
+        "types": [
           {
-          "type": "identifier",
+            "type": "expression",
-          "named": true
-        },
-        {
-          "type": "item",
             "named": true
           }
         ]
+      },
+      "predicate": {
+        "multiple": false,
+        "required": true,
+        "types": [
+          {
+            "type": "statement",
+            "named": true
+          }
+        ]
+      },
+      "statement_id": {
+        "multiple": false,
+        "required": true,
+        "types": [
+          {
+            "type": "identifier",
+            "named": true
+          }
+        ]
+      }
     }
   },
   {
@@ -165,7 +188,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -193,7 +216,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -212,7 +235,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -318,21 +341,6 @@
     "named": true,
     "fields": {}
   },
-  {
-    "type": "item",
-    "named": true,
-    "fields": {},
-    "children": {
-      "multiple": true,
-      "required": true,
-      "types": [
-        {
-          "type": "statement",
-          "named": true
-        }
-      ]
-    }
-  },
   {
     "type": "list",
     "named": true,
@@ -376,16 +384,31 @@
     "type": "map",
     "named": true,
     "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "assignment",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "match",
+    "named": true,
+    "fields": {},
     "children": {
       "multiple": true,
-      "required": false,
+      "required": true,
       "types": [
         {
           "type": "expression",
           "named": true
         },
         {
-          "type": "identifier",
+          "type": "statement",
           "named": true
         }
       ]
@@ -415,6 +438,29 @@
     "named": true,
     "fields": {}
   },
+  {
+    "type": "reduce",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "expression",
+          "named": true
+        },
+        {
+          "type": "identifier",
+          "named": true
+        },
+        {
+          "type": "statement",
+          "named": true
+        }
+      ]
+    }
+  },
   {
     "type": "remove",
     "named": true,
@@ -432,7 +478,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -447,7 +493,7 @@
       "required": true,
       "types": [
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -470,7 +516,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -481,7 +527,7 @@
     "named": true,
     "fields": {},
     "children": {
-      "multiple": false,
+      "multiple": true,
       "required": true,
       "types": [
         {
@@ -520,6 +566,14 @@
           "type": "insert",
           "named": true
         },
+        {
+          "type": "match",
+          "named": true
+        },
+        {
+          "type": "reduce",
+          "named": true
+        },
         {
           "type": "remove",
           "named": true
@@ -590,7 +644,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -652,7 +706,7 @@
           "named": true
         },
         {
-          "type": "item",
+          "type": "statement",
           "named": true
         }
       ]
@@ -702,10 +756,6 @@
     "type": "-=",
     "named": false
   },
-  {
-    "type": ".",
-    "named": false
-  },
   {
     "type": "..",
     "named": false
@@ -734,6 +784,10 @@
     "type": "==",
     "named": false
   },
+  {
+    "type": "=>",
+    "named": false
+  },
   {
     "type": ">",
     "named": false
@@ -846,6 +900,10 @@
     "type": "length",
     "named": false
   },
+  {
+    "type": "match",
+    "named": false
+  },
   {
     "type": "metadata",
     "named": false
@@ -886,6 +944,10 @@
     "type": "read",
     "named": false
   },
+  {
+    "type": "reduce",
+    "named": false
+  },
   {
     "type": "remove",
     "named": false
@@ -914,6 +976,10 @@
     "type": "table",
     "named": false
   },
+  {
+    "type": "to",
+    "named": false
+  },
   {
     "type": "to_float",
     "named": false