Implement type system; Modify use; Write docs

src/abstract_tree/for.rs

@@ -4,6 +4,7 @@ use tree_sitter::Node;
 
 use crate::{AbstractTree, Block, Error, Expression, Identifier, Map, Result, Type, Value};
 
+/// Abstract representation of a for loop statement.
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct For {
     is_async: bool,

src/abstract_tree/identifier.rs

@@ -3,6 +3,10 @@ use tree_sitter::Node;
 
 use crate::{AbstractTree, Error, Map, Result, Type, Value, BUILT_IN_FUNCTIONS};
 
+/// A string by which a variable is known to a context.
+///
+/// Every variable is a key-value pair. An identifier holds the key part of that
+/// pair. Its inner value can be used to retrieve a Value instance from a Map.
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Identifier(String);
 

src/abstract_tree/match.rs

@@ -6,21 +6,97 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Map, Result, Type, Value};
+use crate::{AbstractTree, Error, Expression, Map, Result, Statement, Type, Value};
 
+/// Abstract representation of a match statement.
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
-pub struct Match {}
+pub struct Match {
+    matcher: Expression,
+    options: Vec<(Expression, Statement)>,
+}
 
 impl AbstractTree for Match {
-    fn from_syntax_node(_source: &str, _node: Node, _context: &Map) -> Result<Self> {
+    fn from_syntax_node(source: &str, node: Node, context: &Map) -> Result<Self> {
-        todo!()
+        Error::expect_syntax_node(source, "match", node)?;
+
+        let matcher_node = node.child(1).unwrap();
+        let matcher = Expression::from_syntax_node(source, matcher_node, context)?;
+
+        let mut options = Vec::new();
+        let mut previous_expression = None;
+
+        for index in 2..node.child_count() {
+            let child = node.child(index).unwrap();
+
+            if child.kind() == "expression" {
+                previous_expression = Some(Expression::from_syntax_node(source, child, context)?);
+            }
+
+            if child.kind() == "statement" {
+                if let Some(expression) = &previous_expression {
+                    let statement = Statement::from_syntax_node(source, child, context)?;
+
+                    options.push((expression.clone(), statement));
+                }
+            }
+        }
+
+        Ok(Match { matcher, options })
     }
 
-    fn run(&self, _source: &str, _context: &Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
-        todo!()
+        let matcher_value = self.matcher.run(source, context)?;
+
+        for (expression, statement) in &self.options {
+            let option_value = expression.run(source, context)?;
+
+            if matcher_value == option_value {
+                return statement.run(source, context);
+            }
+        }
+
+        Ok(Value::Empty)
     }
 
     fn expected_type(&self, _context: &Map) -> Result<Type> {
         todo!()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{evaluate, Value};
+
+    #[test]
+    fn evaluate_match() {
+        let test = evaluate(
+            "
+                match 1 {
+                    3 => false
+                    2 => { false }
+                    1 => true
+                }
+            ",
+        )
+        .unwrap();
+
+        assert_eq!(Value::Boolean(true), test);
+    }
+
+    #[test]
+    fn evaluate_match_assignment() {
+        let test = evaluate(
+            "
+                x = match 1 {
+                    3 => false
+                    2 => { false }
+                    1 => true
+                }
+                x
+            ",
+        )
+        .unwrap();
+
+        assert_eq!(Value::Boolean(true), test);
+    }
+}

src/abstract_tree/statement.rs

@@ -34,32 +34,39 @@ impl AbstractTree for Statement {
             "return" => {
                 let expression_node = child.child(1).unwrap();
 
-                Ok(Statement::Return(Expression::from_syntax_node(source, expression_node, context)?))
+                Ok(Statement::Return(Expression::from_syntax_node(
-            },
+                    source,
+                    expression_node,
+                    context,
+                )?))
+            }
             "expression" => Ok(Statement::Expression(Expression::from_syntax_node(
-                source, child, context
+                source, child, context,
             )?)),
             "if_else" => Ok(Statement::IfElse(Box::new(IfElse::from_syntax_node(
-                source, child, context
+                source, child, context,
-            )?))),
-            "tool" => Ok(Statement::IfElse(Box::new(IfElse::from_syntax_node(
-                source, child, context
             )?))),
             "while" => Ok(Statement::While(Box::new(While::from_syntax_node(
-                source, child, context
+                source, child, context,
             )?))),
             "block" => Ok(Statement::Block(Box::new(Block::from_syntax_node(
-                source, child, context
+                source, child, context,
             )?))),
             "for" => Ok(Statement::For(Box::new(For::from_syntax_node(
-                source, child, context
+                source, child, context,
-            )?))),
-            "use" => Ok(Statement::Use(Use::from_syntax_node(source, child, context)?)),
-            "index_assignment" => Ok(Statement::IndexAssignment(Box::new(IndexAssignment::from_syntax_node(
-                source, child, context
             )?))),
+            "use" => Ok(Statement::Use(Use::from_syntax_node(
+                source, child, context,
+            )?)),
+            "index_assignment" => Ok(Statement::IndexAssignment(Box::new(
+                IndexAssignment::from_syntax_node(source, child, context)?,
+            ))),
+            "match" => Ok(Statement::Match(Match::from_syntax_node(
+                source, child, context,
+            )?)),
             _ => Err(Error::UnexpectedSyntaxNode {
-                expected: "assignment, expression, if...else, while, for, transform, filter, tool, async, find, remove, select, insert, index_assignment or yield",
+                expected:
+                    "assignment, expression, block, return, if...else, while, for, index_assignment or match",
                 actual: child.kind(),
                 location: child.start_position(),
                 relevant_source: source[child.byte_range()].to_string(),

src/abstract_tree/use.rs

@@ -5,6 +5,11 @@ use tree_sitter::Node;
 
 use crate::{evaluate_with_context, AbstractTree, Error, Map, Result, Type, Value};
 
+/// Abstract representation of a use statement.
+///
+/// Use will evaluate the Dust file at the given path. It will create an empty
+/// context to do so, then apply every value from that context to the current
+/// context.
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Use {
     path: String,
@@ -20,12 +25,16 @@ impl AbstractTree for Use {
         Ok(Use { path })
     }
 
-    fn run(&self, _source: &str, _context: &Map) -> Result<Value> {
+    fn run(&self, _source: &str, context: &Map) -> Result<Value> {
         let file_contents = read_to_string(&self.path)?;
         let mut file_context = Map::new();
 
         evaluate_with_context(&file_contents, &mut file_context)?;
 
+        for (key, value) in file_context.variables()?.iter() {
+            context.variables_mut()?.insert(key.clone(), value.clone());
+        }
+
         Ok(Value::Map(file_context))
     }
 

src/built_in_functions/mod.rs

@@ -1,3 +1,4 @@
+/// Built-in functions that are available to all Dust programs.
 use crate::{Map, Result, Type, Value};
 
 mod assert;
@@ -9,7 +10,11 @@ mod output;
 mod random;
 mod r#type;
 
-pub const BUILT_IN_FUNCTIONS: [&dyn BuiltInFunction; 14] = [
+/// All built-in functions recognized by the interpreter.
+///
+/// This is the public interface to access built-in functions by iterating over
+/// the references it holds.
+pub const BUILT_IN_FUNCTIONS: [&dyn BuiltInFunction; 15] = [
     &assert::Assert,
     &assert::AssertEqual,
     &collections::Length,
@@ -18,6 +23,7 @@ pub const BUILT_IN_FUNCTIONS: [&dyn BuiltInFunction; 14] = [
     &fs::Read,
     &fs::Write,
     &fs::Append,
+    &network::Download,
     &output::Output,
     &random::Random,
     &random::RandomBoolean,

tree-sitter-dust/corpus/match.txt

@@ -0,0 +1,34 @@
+================================================================================
+Match Values
+================================================================================
+
+match x {
+  1 => {
+    true
+  }
+  2 => false
+}
+
+--------------------------------------------------------------------------------
+
+(root
+  (statement
+    (match
+      (expression
+        (identifier))
+      (expression
+        (value
+          (integer)))
+      (statement
+        (block
+          (statement
+            (expression
+              (value
+                (boolean))))))
+      (expression
+        (value
+          (integer)))
+      (statement
+        (expression
+          (value
+            (boolean)))))))

tree-sitter-dust/grammar.js

@@ -282,13 +282,15 @@ module.exports = grammar({
         seq(
           'match',
           $.expression,
+          '{',
           repeat1(
             seq(
               $.expression,
               '=>',
-              $.block,
+              $.statement,
             ),
           ),
+          '}',
         ),
       ),
 

tree-sitter-dust/src/grammar.json

@@ -886,6 +886,10 @@
             "type": "SYMBOL",
             "name": "expression"
           },
+          {
+            "type": "STRING",
+            "value": "{"
+          },
           {
             "type": "REPEAT1",
             "content": {
@@ -901,10 +905,14 @@
                 },
                 {
                   "type": "SYMBOL",
-                  "name": "block"
+                  "name": "statement"
                 }
               ]
             }
+          },
+          {
+            "type": "STRING",
+            "value": "}"
           }
         ]
       }

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

@@ -328,11 +328,11 @@
       "required": true,
       "types": [
         {
-          "type": "block",
+          "type": "expression",
           "named": true
         },
         {
-          "type": "expression",
+          "type": "statement",
           "named": true
         }
       ]