README.md

@@ -28,7 +28,7 @@ if (random_boolean) {
 }
 ```
 
-Dust is an interpreted, strictly typed language with first class functions. It emphasises concurrency by allowing any group of statements to be executed in parallel. Dust includes built-in tooling to import and export data in a variety of formats, including JSON, TOML, YAML and CSV.
+Dust is an interpreted, dynamically typed language with first class functions. It emphasises concurrency by allowing any group of statements to be executed in parallel. It is *data-oriented*, with extensive tools to manage structured and relational data. Dust includes built-in tooling to import and export data in a variety of formats, including JSON, TOML, YAML and CSV.
 
 <!--toc:start-->
 - [Dust](#dust)
@@ -50,10 +50,10 @@ Dust is an interpreted, strictly typed language with first class functions. It e
 ## Features
 
 - Simplicity: Dust is designed to be easy to learn.
-- Speed: Dust is built on [Tree Sitter] and [Rust] to prioritize performance and correctness. See [Benchmarks] below.
+- Speed: Dust is built on [Tree Sitter] and [Rust] to prioritize performance and correctness.
-- Concurrency: Easily and safely write code that runs in parallel.
+- Data format: Dust is data-oriented, making it a great language for defining data.
-- Safety: Written in safe, stable Rust.
+- Format conversion: Effortlessly convert between dust and formats like JSON, CSV and TOML.
-- Correctness: Type checking makes it easy to write good code that works.
+- Structured data: Dust can represent data with more than just strings. Lists, maps and tables are easy to make and manage.
 
 ## Usage
 

src/abstract_tree/assignment.rs

@@ -1,12 +1,11 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Identifier, Map, Result, Statement, Type, Value};
+use crate::{AbstractTree, Error, Identifier, Map, Result, Statement, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Assignment {
     identifier: Identifier,
-    r#type: Option<Type>,
     operator: AssignmentOperator,
     statement: Statement,
 }
@@ -22,21 +21,10 @@ impl AbstractTree for Assignment {
     fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
         Error::expect_syntax_node(source, "assignment", node)?;
 
-        let identifier_node = node.child_by_field_name("identifier").unwrap();
+        let identifier_node = node.child(0).unwrap();
         let identifier = Identifier::from_syntax_node(source, identifier_node)?;
 
-        let type_node = node.child_by_field_name("type");
+        let operator_node = node.child(1).unwrap().child(0).unwrap();
-        let r#type = if let Some(type_node) = type_node {
-            Some(Type::from_syntax_node(source, type_node)?)
-        } else {
-            None
-        };
-
-        let operator_node = node
-            .child_by_field_name("assignment_operator")
-            .unwrap()
-            .child(0)
-            .unwrap();
         let operator = match operator_node.kind() {
             "=" => AssignmentOperator::Equal,
             "+=" => AssignmentOperator::PlusEqual,
@@ -51,12 +39,11 @@ impl AbstractTree for Assignment {
             }
         };
 
-        let statement_node = node.child_by_field_name("statement").unwrap();
+        let statement_node = node.child(2).unwrap();
         let statement = Statement::from_syntax_node(source, statement_node)?;
 
         Ok(Assignment {
             identifier,
-            r#type,
             operator,
             statement,
         })
@@ -86,28 +73,6 @@ impl AbstractTree for Assignment {
             AssignmentOperator::Equal => value,
         };
 
-        let expected_type = self.r#type.as_ref().unwrap_or(&Type::Any);
-
-        match (expected_type, new_value.r#type()) {
-            (Type::Any, _)
-            | (Type::Boolean, Type::Boolean)
-            | (Type::Float, Type::Float)
-            | (Type::Function, Type::Function)
-            | (Type::Integer, Type::Integer)
-            | (Type::List, Type::List)
-            | (Type::Map, Type::Map)
-            | (Type::String, Type::String)
-            | (Type::Table, Type::Table) => {}
-            (Type::Boolean, _) => return Err(Error::ExpectedBoolean { actual: new_value }),
-            (Type::Float, _) => return Err(Error::ExpectedFloat { actual: new_value }),
-            (Type::Function, _) => return Err(Error::ExpectedFunction { actual: new_value }),
-            (Type::Integer, _) => return Err(Error::ExpectedInteger { actual: new_value }),
-            (Type::List, _) => return Err(Error::ExpectedList { actual: new_value }),
-            (Type::Map, _) => return Err(Error::ExpectedMap { actual: new_value }),
-            (Type::String, _) => return Err(Error::ExpectedString { actual: new_value }),
-            (Type::Table, _) => return Err(Error::ExpectedTable { actual: new_value }),
-        }
-
         context.variables_mut()?.insert(key, new_value);
 
         Ok(Value::Empty)

src/abstract_tree/type.rs

@@ -5,7 +5,6 @@ use crate::{AbstractTree, Error, Map, Result, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Type {
-    Any,
     Boolean,
     Float,
     Function,
@@ -20,10 +19,7 @@ impl AbstractTree for Type {
     fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
         Error::expect_syntax_node(source, "type", node)?;
 
-        let range_without_punctuation = node.start_byte() + 1..node.end_byte() - 1;
+        let r#type = match &source[node.byte_range()] {
-
-        let r#type = match &source[range_without_punctuation] {
-            "any" => Type::Any,
             "bool" => Type::Boolean,
             "float" => Type::Float,
             "fn" => Type::Function,
@@ -46,6 +42,15 @@ impl AbstractTree for Type {
     }
 
     fn run(&self, _source: &str, _context: &mut Map) -> Result<Value> {
-        Ok(Value::Empty)
+        match self {
+            Type::Boolean => Ok(Value::String("bool".to_string())),
+            Type::Float => Ok(Value::String("float".to_string())),
+            Type::Function => Ok(Value::String("fn".to_string())),
+            Type::Integer => Ok(Value::String("int".to_string())),
+            Type::List => Ok(Value::String("list".to_string())),
+            Type::Map => Ok(Value::String("map".to_string())),
+            Type::String => Ok(Value::String("string".to_string())),
+            Type::Table => Ok(Value::String("table".to_string())),
+        }
     }
 }

src/error.rs

@@ -59,7 +59,7 @@ pub enum Error {
         actual: Value,
     },
 
-    ExpectedInteger {
+    ExpectedInt {
         actual: Value,
     },
 
@@ -270,20 +270,24 @@ impl fmt::Display for Error {
                 "{identifier} expected a minimum of {minimum} arguments, but got {actual}.",
             ),
             ExpectedString { actual } => {
-                write!(f, "Expected a string but got {:?}.", actual)
+                write!(f, "Expected a Value::String, but got {:?}.", actual)
-            }
-            ExpectedInteger { actual } => write!(f, "Expected an integer, but got {:?}.", actual),
-            ExpectedFloat { actual } => write!(f, "Expected a float, but got {:?}.", actual),
-            ExpectedNumber { actual } => {
-                write!(f, "Expected a float or integer but got {:?}.", actual)
-            }
-            ExpectedNumberOrString { actual } => {
-                write!(f, "Expected a number or string, but got {:?}.", actual)
             }
+            ExpectedInt { actual } => write!(f, "Expected a Value::Int, but got {:?}.", actual),
+            ExpectedFloat { actual } => write!(f, "Expected a Value::Float, but got {:?}.", actual),
+            ExpectedNumber { actual } => write!(
+                f,
+                "Expected a Value::Float or Value::Int, but got {:?}.",
+                actual
+            ),
+            ExpectedNumberOrString { actual } => write!(
+                f,
+                "Expected a Value::Number or a Value::String, but got {:?}.",
+                actual
+            ),
             ExpectedBoolean { actual } => {
-                write!(f, "Expected a boolean, but got {:?}.", actual)
+                write!(f, "Expected a Value::Boolean, but got {:?}.", actual)
             }
-            ExpectedList { actual } => write!(f, "Expected a list, but got {:?}.", actual),
+            ExpectedList { actual } => write!(f, "Expected a Value::List, but got {:?}.", actual),
             ExpectedMinLengthList {
                 minimum_len,
                 actual_len,
@@ -296,14 +300,14 @@ impl fmt::Display for Error {
                 actual,
             } => write!(
                 f,
-                "Expected a list of len {}, but got {:?}.",
+                "Expected a Value::List of len {}, but got {:?}.",
                 expected_len, actual
             ),
-            ExpectedEmpty { actual } => write!(f, "Expected an empty value, but got {:?}.", actual),
+            ExpectedEmpty { actual } => write!(f, "Expected a Value::Empty, but got {:?}.", actual),
-            ExpectedMap { actual } => write!(f, "Expected a map, but got {:?}.", actual),
+            ExpectedMap { actual } => write!(f, "Expected a Value::Map, but got {:?}.", actual),
-            ExpectedTable { actual } => write!(f, "Expected a table, but got {:?}.", actual),
+            ExpectedTable { actual } => write!(f, "Expected a Value::Table, but got {:?}.", actual),
             ExpectedFunction { actual } => {
-                write!(f, "Expected function, but got {:?}.", actual)
+                write!(f, "Expected Value::Function, but got {:?}.", actual)
             }
             ExpectedCollection { actual } => {
                 write!(

src/value/mod.rs

@@ -52,9 +52,9 @@ impl Value {
             Value::Function(_) => Type::Function,
             Value::String(_) => Type::String,
             Value::Float(_) => Type::Float,
-            Value::Integer(_) => Type::Integer,
+            Value::Integer(_) => todo!(),
-            Value::Boolean(_) => Type::Boolean,
+            Value::Boolean(_) => todo!(),
-            Value::Empty => Type::Any,
+            Value::Empty => todo!(),
         }
     }
 
@@ -116,7 +116,7 @@ impl Value {
     pub fn as_integer(&self) -> Result<i64> {
         match self {
             Value::Integer(i) => Ok(*i),
-            value => Err(Error::ExpectedInteger {
+            value => Err(Error::ExpectedInt {
                 actual: value.clone(),
             }),
         }
@@ -540,7 +540,7 @@ impl TryFrom<Value> for i64 {
         if let Value::Integer(value) = value {
             Ok(value)
         } else {
-            Err(Error::ExpectedInteger { actual: value })
+            Err(Error::ExpectedInt { actual: value })
         }
     }
 }

tree-sitter-dust/corpus/assignment.txt

@@ -15,24 +15,6 @@ x = y
         (expression
           (identifier))))))
 
-================================================================================
-Simple Assignment with Type
-================================================================================
-
-x <int> = y
-
---------------------------------------------------------------------------------
-
-(root
-  (statement
-    (assignment
-      (identifier)
-      (type)
-      (assignment_operator)
-      (statement
-        (expression
-          (identifier))))))
-
 ================================================================================
 Map Item Assignment
 ================================================================================

tree-sitter-dust/corpus/functions.txt

@@ -62,7 +62,7 @@ Function Call
 Complex Function
 ================================================================================
 
-|message <str> number <int>| => {
+|message:str number:int| => {
   (output message)
   (output number)
 }
@@ -75,9 +75,9 @@ Complex Function
       (value
         (function
           (identifier)
-          (type)
+          (type_definition)
           (identifier)
-          (type)
+          (type_definition)
           (block
             (statement
               (expression

tree-sitter-dust/grammar.js

@@ -44,7 +44,7 @@ module.exports = grammar({
       seq('(', $._expression_kind, ')'),
     )),
 
-    _expression_kind: $ => prec.right(choice(
+    _expression_kind: $ => choice(
       $.function_call,
       $.identifier,
       $.index,
@@ -52,7 +52,7 @@ module.exports = grammar({
       $.math,
       $.value,
       $.yield,
-    )),
+    ),
 
     _expression_list: $ => repeat1(prec.right(seq(
       $.expression,
@@ -152,10 +152,9 @@ module.exports = grammar({
     ),
 
     assignment: $ => seq(
-      field('identifier', $.identifier),
+      $.identifier,
-      optional(field('type', $.type)),
+      $.assignment_operator,
-      field('assignment_operator', $.assignment_operator),
+      $.statement,
-      field('statement', $.statement),
     ),
 
     index_assignment: $ => seq(
@@ -259,10 +258,7 @@ module.exports = grammar({
       $.string,
     ),
 
-    type: $ => seq(
+    type_definition: $ => choice(
-      '<',
-      choice(
-        'any',
       'bool',
       'fn',
       'int',
@@ -271,15 +267,14 @@ module.exports = grammar({
       'str',
       'table',
     ),
-      '>',
-    ),
   
     function: $ => seq(
       optional(seq(
         '|',
         field('parameter', repeat(seq(
           $.identifier,
-          $.type,
+          ':',
+          $.type_definition,
           optional(',')
         ))),
         '|',

tree-sitter-dust/src/grammar.json

@@ -154,9 +154,6 @@
       }
     },
     "_expression_kind": {
-      "type": "PREC_RIGHT",
-      "value": 0,
-      "content": {
       "type": "CHOICE",
       "members": [
         {
@@ -188,7 +185,6 @@
           "name": "yield"
         }
       ]
-      }
     },
     "_expression_list": {
       "type": "REPEAT1",
@@ -708,45 +704,17 @@
       "type": "SEQ",
       "members": [
         {
-          "type": "FIELD",
-          "name": "identifier",
-          "content": {
           "type": "SYMBOL",
           "name": "identifier"
-          }
         },
         {
-          "type": "CHOICE",
-          "members": [
-            {
-              "type": "FIELD",
-              "name": "type",
-              "content": {
-                "type": "SYMBOL",
-                "name": "type"
-              }
-            },
-            {
-              "type": "BLANK"
-            }
-          ]
-        },
-        {
-          "type": "FIELD",
-          "name": "assignment_operator",
-          "content": {
           "type": "SYMBOL",
           "name": "assignment_operator"
-          }
         },
         {
-          "type": "FIELD",
-          "name": "statement",
-          "content": {
           "type": "SYMBOL",
           "name": "statement"
         }
-        }
       ]
     },
     "index_assignment": {
@@ -1105,20 +1073,9 @@
         }
       ]
     },
-    "type": {
+    "type_definition": {
-      "type": "SEQ",
-      "members": [
-        {
-          "type": "STRING",
-          "value": "<"
-        },
-        {
       "type": "CHOICE",
       "members": [
-            {
-              "type": "STRING",
-              "value": "any"
-            },
         {
           "type": "STRING",
           "value": "bool"
@@ -1149,12 +1106,6 @@
         }
       ]
     },
-        {
-          "type": "STRING",
-          "value": ">"
-        }
-      ]
-    },
     "function": {
       "type": "SEQ",
       "members": [
@@ -1180,9 +1131,13 @@
                           "type": "SYMBOL",
                           "name": "identifier"
                         },
+                        {
+                          "type": "STRING",
+                          "value": ":"
+                        },
                         {
                           "type": "SYMBOL",
-                          "name": "type"
+                          "name": "type_definition"
                         },
                         {
                           "type": "CHOICE",

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

@@ -2,47 +2,24 @@
   {
     "type": "assignment",
     "named": true,
-    "fields": {
+    "fields": {},
-      "assignment_operator": {
+    "children": {
-        "multiple": false,
+      "multiple": true,
       "required": true,
       "types": [
         {
           "type": "assignment_operator",
           "named": true
-          }
-        ]
         },
-      "identifier": {
-        "multiple": false,
-        "required": true,
-        "types": [
         {
           "type": "identifier",
           "named": true
-          }
-        ]
         },
-      "statement": {
-        "multiple": false,
-        "required": true,
-        "types": [
         {
           "type": "statement",
           "named": true
         }
       ]
-      },
-      "type": {
-        "multiple": false,
-        "required": false,
-        "types": [
-          {
-            "type": "type",
-            "named": true
-          }
-        ]
-      }
     }
   },
   {
@@ -203,12 +180,16 @@
             "type": ",",
             "named": false
           },
+          {
+            "type": ":",
+            "named": false
+          },
           {
             "type": "identifier",
             "named": true
           },
           {
-            "type": "type",
+            "type": "type_definition",
             "named": true
           }
         ]
@@ -581,7 +562,7 @@
     }
   },
   {
-    "type": "type",
+    "type": "type_definition",
     "named": true,
     "fields": {}
   },
@@ -781,10 +762,6 @@
     "type": "]",
     "named": false
   },
-  {
-    "type": "any",
-    "named": false
-  },
   {
     "type": "append",
     "named": false