Add calls

Author: Cypher1

takolib/src/ast/mod.rs

@@ -70,6 +70,20 @@ impl Ast {
         }
         eq
     }
+    pub fn add_args(&mut self, node_id: NodeId, args: SmallVec<NodeId, CALL_ARGS_STANDARD_ITEM_NUM>) -> NodeId {
+        let location = self[node_id].location;
+        let id = self[node_id].id.clone();
+        match id {
+            NodeData::Identifier(_) | NodeData::Call(_) => {
+                let call = Call {
+                    inner: node_id,
+                    args,
+                };
+                self.add_call(call, location)
+            }
+            node => todo!("Assignment to non definition head support: {node:?}"),
+        }
+    }
     pub fn add_implementation(&mut self, node_id: NodeId, imp: NodeId) -> NodeId {
         use crate::parser::semantics::BindingMode;
         let location = self[node_id].location;

takolib/src/ast/nodes.rs

@@ -6,7 +6,7 @@ use crate::parser::tokens::Symbol;
 use smallvec::SmallVec;
 
 pub const OP_ARGS_STANDARD_ITEM_NUM: usize = 2;
-pub const CALL_ARGS_STANDARD_ITEM_NUM: usize = 5;
+pub const CALL_ARGS_STANDARD_ITEM_NUM: usize = 2;
 pub const FMT_STR_STANDARD_ITEM_NUM: usize = 2; // TODO: Convert to a different store
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]

takolib/src/parser/mod.rs

@@ -174,7 +174,7 @@ fn language<'src, 'ast>() -> impl Parser<'src, &'src [Token], (), ParserConfig<'
             .labelled("an ordered set of values");
 
         let unordered_container = op(Symbol::OpenCurly)
-            .then(many)
+            .then(many.clone())
             .then(op(Symbol::CloseCurly))
             .map_with(|((open, nodes), _close), extra| {
                 let ast: &mut Ast = std::ops::DerefMut::deref_mut(extra.state());
@@ -236,13 +236,8 @@ fn language<'src, 'ast>() -> impl Parser<'src, &'src [Token], (), ParserConfig<'
         };
 
         /*
-        Source: https://www.foonathan.net/2017/07/operator-precedence/
-        Inside the categories the relative precedence of the operators is as follows:
-            logical operators: ! > &&,||, but not mixed && and || chains
-            comparison operators: no chaining at all
-            mathematical operators: unary +,- > *,/ > +,-, with the usual associativity
-            bitwise operators: unary ~ before the binary operators, but again no mixed chaining of &, | and ^ and no chaining of the shift operators
-            unary operators: just as usual
+        For reference, some interesting ideas about partial ordering of precedences:
+            - https://www.foonathan.net/2017/07/operator-precedence/
         */
 
         use Symbol::*;
@@ -308,9 +303,23 @@ fn language<'src, 'ast>() -> impl Parser<'src, &'src [Token], (), ParserConfig<'
         // postfix_op(11, Try),
         // infix_op(left(9), DoubleArrow),
         // infix_op(left(8), Arrow),
+        let params = many
+            .clone()
+            .delimited_by(op(Symbol::OpenParen), op(Symbol::CloseParen))
+            .labelled("a set of parameters");
+
+        let callable = expr
+            .clone()
+            .then(params)
+            .map_with(|(lhs, rhs), extra| {
+                let ast: &mut Ast = std::ops::DerefMut::deref_mut(extra.state());
+                ast.add_args(lhs, rhs)
+            })
+            .labelled("a callable");
 
         let expr = math_expr
             .clone()
+            .or(callable)
             .or(boolean_expr)
             .or(comparison)
             .or(lshift_expr)