Implement yield logic; Reform yield syntax

examples/yield.ds

@@ -1,9 +1,12 @@
 1 -> (output)
 
-add_one = |list| {
+add_one = |list| => {
 	transform number in list {
 		number + 1
 	}
 }
 
-[1, 2, 3] -> (add_one)
+foo = [1, 2, 3] -> (add_one)
+
+(assert_equal [2 3 4] foo)
+

src/abstract_tree/expression.rs

@@ -3,7 +3,7 @@ use tree_sitter::Node;
 
 use crate::{
     value_node::ValueNode, AbstractTree, BuiltInFunction, Error, Identifier, Index, Map, Result,
-    Value,
+    Value, Yield,
 };
 
 use super::{function_call::FunctionCall, logic::Logic, math::Math};
@@ -17,42 +17,41 @@ pub enum Expression {
     Logic(Box<Logic>),
     FunctionCall(FunctionCall),
     Tool(Box<BuiltInFunction>),
+    Yield(Yield),
 }
 
 impl AbstractTree for Expression {
     fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
         Error::expect_syntax_node(source, "expression", node)?;
 
-        for index in 0..node.child_count() {
+        let child = if node.child(0).unwrap().is_named() {
-            let child = node.child(index).unwrap();
+            node.child(0).unwrap()
-            let expression = match child.kind() {
+        } else {
-                "value" => Expression::Value(ValueNode::from_syntax_node(source, child)?),
+            node.child(1).unwrap()
-                "identifier" => {
+        };
-                    Expression::Identifier(Identifier::from_syntax_node(source, child)?)
-                }
-                "index" => Expression::Index(Box::new(Index::from_syntax_node(source, child)?)),
-                "math" => Expression::Math(Box::new(Math::from_syntax_node(source, child)?)),
-                "logic" => Expression::Logic(Box::new(Logic::from_syntax_node(source, child)?)),
-                "function_call" => {
-                    Expression::FunctionCall(FunctionCall::from_syntax_node(source, child)?)
-                }
-                "tool" => {
-                    Expression::Tool(Box::new(BuiltInFunction::from_syntax_node(source, child)?))
-                }
-                _ => continue,
-            };
 
-            return Ok(expression);
+        let expression = match child.kind() {
-        }
+            "value" => Expression::Value(ValueNode::from_syntax_node(source, child)?),
+            "identifier" => Expression::Identifier(Identifier::from_syntax_node(source, child)?),
+            "index" => Expression::Index(Box::new(Index::from_syntax_node(source, child)?)),
+            "math" => Expression::Math(Box::new(Math::from_syntax_node(source, child)?)),
+            "logic" => Expression::Logic(Box::new(Logic::from_syntax_node(source, child)?)),
+            "function_call" => {
+                Expression::FunctionCall(FunctionCall::from_syntax_node(source, child)?)
+            }
+            "tool" => Expression::Tool(Box::new(BuiltInFunction::from_syntax_node(source, child)?)),
+            "yield" => Expression::Yield(Yield::from_syntax_node(source, child)?),
+            _ => {
+                return Err(Error::UnexpectedSyntaxNode {
+                    expected: "value, identifier, index, math, logic, function_call or yield",
+                    actual: child.kind(),
+                    location: child.start_position(),
+                    relevant_source: source[child.byte_range()].to_string(),
+                })
+            }
+        };
 
-        let child = node.child(0).unwrap();
+        Ok(expression)
-
-        Err(Error::UnexpectedSyntaxNode {
-            expected: "value, identifier, sublist, index, math or function_call",
-            actual: child.kind(),
-            location: child.start_position(),
-            relevant_source: source[child.byte_range()].to_string(),
-        })
     }
 
     fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
@@ -64,6 +63,7 @@ impl AbstractTree for Expression {
             Expression::FunctionCall(function_call) => function_call.run(source, context),
             Expression::Tool(tool) => tool.run(source, context),
             Expression::Index(index) => index.run(source, context),
+            Expression::Yield(r#yield) => r#yield.run(source, context),
         }
     }
 }

src/abstract_tree/mod.rs

@@ -28,12 +28,13 @@ pub mod statement;
 pub mod transform;
 pub mod value_node;
 pub mod r#while;
+pub mod r#yield;
 
 pub use {
     assignment::*, block::*, built_in_function::*, expression::*, filter::*, find::*,
     function_call::*, identifier::*, if_else::*, index::*, index_assignment::*, insert::*,
-    logic::*, math::*, r#for::*, r#match::*, r#while::*, remove::*, select::*, statement::*,
+    logic::*, math::*, r#for::*, r#match::*, r#while::*, r#yield::*, remove::*, select::*,
-    transform::*, value_node::*,
+    statement::*, transform::*, value_node::*,
 };
 
 use tree_sitter::Node;

src/abstract_tree/statement.rs

@@ -78,7 +78,7 @@ impl AbstractTree for Statement {
                 source, child,
             )?))),
             _ => Err(Error::UnexpectedSyntaxNode {
-                expected: "assignment, expression, if...else, while, for, transform, filter, tool, async, find, remove, select, insert or index_assignment",
+                expected: "assignment, expression, if...else, while, for, transform, filter, tool, async, find, remove, select, insert, index_assignment or yield",
                 actual: child.kind(),
                 location: child.start_position(),
                 relevant_source: source[child.byte_range()].to_string(),

src/abstract_tree/yield.rs

@@ -1,11 +1,10 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Expression, Function, FunctionCall, Result, Value, ValueNode};
+use crate::{AbstractTree, BuiltInFunction, Expression, FunctionCall, Identifier, Result, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Yield {
-    input: Expression,
     call: FunctionCall,
 }
 
@@ -14,15 +13,38 @@ impl AbstractTree for Yield {
         let input_node = node.child(0).unwrap();
         let input = Expression::from_syntax_node(source, input_node)?;
 
-        let call_node = node.child(1).unwrap();
+        let function_node = node.child(3).unwrap();
-        let call = FunctionCall::from_syntax_node(source, call_node)?;
+        let mut arguments = Vec::new();
 
-        Ok(Yield { input, call })
+        arguments.push(input);
+
+        for index in 4..node.child_count() - 1 {
+            let node = node.child(index).unwrap();
+
+            if node.is_named() {
+                let expression = Expression::from_syntax_node(source, node)?;
+
+                arguments.push(expression);
+            }
+        }
+
+        let call = if function_node.kind() == "built_in_function" {
+            let function = BuiltInFunction::from_syntax_node(source, function_node)?;
+
+            FunctionCall::BuiltIn(Box::new(function))
+        } else {
+            let identifier = Identifier::from_syntax_node(source, function_node)?;
+
+            FunctionCall::ContextDefined {
+                name: identifier,
+                arguments,
+            }
+        };
+
+        Ok(Yield { call })
     }
 
     fn run(&self, source: &str, context: &mut crate::Map) -> Result<Value> {
-        let target = self.input.run(source, context)?.as_function()?;
+        self.call.run(source, context)
-
-        self.call.run(, )
     }
 }

tree-sitter-dust/corpus/yield.txt

@@ -13,8 +13,7 @@ Simple Yield
         (expression
           (value
             (integer)))
-        (function_call
+        (built_in_function)))))
-          (built_in_function))))))
 
 ================================================================================
 Yield Chain
@@ -34,9 +33,6 @@ x -> (foo) -> (bar) -> (abc)
               (yield
                 (expression
                   (identifier))
-                (function_call
+                (identifier)))
-                  (identifier))))
+            (identifier)))
-            (function_call
+        (identifier)))))
-              (identifier))))
-        (function_call
-          (identifier))))))

tree-sitter-dust/grammar.js

@@ -45,7 +45,12 @@ module.exports = grammar({
     yield: $ => prec.left(seq(
       $.expression,
       '->',
-      $.function_call,
+      '(',
+      choice(
+        $.built_in_function,
+        $._context_defined_function,
+      ),
+      ')',
     )),
   
     expression: $ => prec.right(choice(

tree-sitter-dust/src/grammar.json

@@ -150,8 +150,25 @@
             "value": "->"
           },
           {
-            "type": "SYMBOL",
+            "type": "STRING",
-            "name": "function_call"
+            "value": "("
+          },
+          {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "built_in_function"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "_context_defined_function"
+              }
+            ]
+          },
+          {
+            "type": "STRING",
+            "value": ")"
           }
         ]
       }

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

@@ -758,12 +758,16 @@
       "multiple": true,
       "required": true,
       "types": [
+        {
+          "type": "built_in_function",
+          "named": true
+        },
         {
           "type": "expression",
           "named": true
         },
         {
-          "type": "function_call",
+          "type": "identifier",
           "named": true
         }
       ]