src/error.rs

@@ -2,7 +2,10 @@
 //!
 //! To deal with errors from dependencies, either create a new error variant
 //! or use the MacroFailure variant if the error can only occur inside a macro.
-use crate::{value::value_type::ValueType, value::Value, ToolInfo};
+use crate::{
+    operator::Operator, token::PartialToken, value::value_type::ValueType, value::Value, Node,
+    ToolInfo,
+};
 
 use std::{fmt, io, time::SystemTimeError};
 
@@ -115,6 +118,10 @@ pub enum Error {
         actual: Value,
     },
 
+    /// Tried to append a child to a leaf node.
+    /// Leaf nodes cannot have children.
+    AppendedToLeafNode(Node),
+
     /// Tried to append a child to a node such that the precedence of the child
     /// is not higher. This error should never occur. If it does, please file a
     /// bug report.
@@ -147,9 +154,9 @@ pub enum Error {
     /// An operator is used with a wrong combination of types.
     WrongTypeCombination {
         /// The operator that whose evaluation caused the error.
-        expected: ValueType,
+        operator: Operator,
         /// The types that were used in the operator causing it to fail.
-        actual: ValueType,
+        actual: Vec<ValueType>,
     },
 
     /// An opening brace without a matching closing brace was found.
@@ -162,6 +169,16 @@ pub enum Error {
     /// For example, writing `4(5)` would yield this error, as the `4` does not have any operands.
     MissingOperatorOutsideOfBrace,
 
+    /// A `PartialToken` is unmatched, such that it cannot be combined into a full `Token`.
+    /// This happens if for example a single `=` is found, surrounded by whitespace.
+    /// It is not a token, but it is part of the string representation of some tokens.
+    UnmatchedPartialToken {
+        /// The unmatched partial token.
+        first: PartialToken,
+        /// The token that follows the unmatched partial token and that cannot be matched to the partial token, or `None`, if `first` is the last partial token in the stream.
+        second: Option<PartialToken>,
+    },
+
     /// An addition operation performed by Rust failed.
     AdditionError {
         /// The first argument of the addition.
@@ -334,6 +351,10 @@ impl Error {
         Error::TypeError { actual, expected }
     }
 
+    pub fn wrong_type_combination(operator: Operator, actual: Vec<ValueType>) -> Self {
+        Error::WrongTypeCombination { operator, actual }
+    }
+
     pub fn expected_string(actual: Value) -> Self {
         Error::ExpectedString { actual }
     }
@@ -389,6 +410,13 @@ impl Error {
         Error::ExpectedCollection { actual }
     }
 
+    pub(crate) fn unmatched_partial_token(
+        first: PartialToken,
+        second: Option<PartialToken>,
+    ) -> Self {
+        Error::UnmatchedPartialToken { first, second }
+    }
+
     pub(crate) fn addition_error(augend: Value, addend: Value) -> Self {
         Error::AdditionError { augend, addend }
     }
@@ -512,6 +540,7 @@ impl fmt::Display for Error {
                     actual
                 )
             }
+            AppendedToLeafNode(node) => write!(f, "Syntax error at \"{node}\"."),
             PrecedenceViolation => write!(
                 f,
                 "Tried to append a node to another node with higher precedence."
@@ -532,6 +561,11 @@ impl fmt::Display for Error {
                     "Type Error. The value {actual} is not one of the following: {expected:?}.",
                 )
             }
+            WrongTypeCombination { operator, actual } => write!(
+                f,
+                "The operator {:?} was called with a wrong combination of types: {:?}",
+                operator, actual
+            ),
             UnmatchedLBrace => write!(f, "Found an unmatched opening parenthesis '('."),
             UnmatchedRBrace => write!(f, "Found an unmatched closing parenthesis ')'."),
             MissingOperatorOutsideOfBrace { .. } => write!(
@@ -540,6 +574,22 @@ impl fmt::Display for Error {
                  any arguments on the right, or found a closing parenthesis that is succeeded by \
                  something that does not take any arguments on the left."
             ),
+            UnmatchedPartialToken { first, second } => {
+                if let Some(second) = second {
+                    write!(
+                        f,
+                        "Found a partial token '{}' that should not be followed by '{}'.",
+                        first, second
+                    )
+                } else {
+                    write!(
+                        f,
+                        "Found a partial token '{}' that should be followed by another partial \
+                         token.",
+                        first
+                    )
+                }
+            }
             AdditionError { augend, addend } => write!(f, "Error adding {} + {}", augend, addend),
             SubtractionError {
                 minuend,
@@ -587,7 +637,6 @@ impl fmt::Display for Error {
             ),
             UnexpectedSourceNode { expected, actual } => write!(f, "Unexpected source node. Expected {expected}, but found {actual}."),
             ExpectedFieldName => write!(f, "Expected a field name for this node, but none was found."),
-            WrongTypeCombination { expected, actual } => write!(f, "Wrong type combination. Expected {expected}, found {actual}."),
         }
     }
 }

src/interface.rs

@@ -1,62 +1,58 @@
-//! The top level of Dust's API with functions to interpret Dust code.
+//! The top level of Dust's API with functions in interpret Dust code.
+
+use std::ops::Range;
 
 use tree_sitter::{Node, Parser, Tree, TreeCursor};
 
 use crate::{language, Error, Result, Value, VariableMap};
 
-/// Evaluate the given source code.
-///
-/// Returns a vector of results from evaluating the source code. Each comment
-/// and statemtent will have its own result.
+/// Evaluate the given expression string.
 ///
 /// # Examples
 ///
 /// ```rust
 /// # use dust_lib::*;
-/// assert_eq!(eval("1 + 2 + 3"), vec![Ok(Value::from(6))]);
+/// assert_eq!(eval("1 + 2 + 3"), Ok(Value::from(6)));
 /// ```
-pub fn eval(source: &str) -> Vec<Result<Value>> {
+///
+/// *See the [crate doc](index.html) for more examples and explanations of the expression format.*
+pub fn eval(source: &str) -> Result<Value> {
     let mut context = VariableMap::new();
 
     eval_with_context(source, &mut context)
 }
 
-/// Evaluate the given source code with the given context.
+/// Evaluate the given expression string with the given context.
 ///
 /// # Examples
 ///
 /// ```rust
 /// # use dust_lib::*;
 /// let mut context = VariableMap::new();
-///
 /// context.set_value("one".into(), 1.into()).unwrap(); // Do proper error handling here
 /// context.set_value("two".into(), 2.into()).unwrap(); // Do proper error handling here
 /// context.set_value("three".into(), 3.into()).unwrap(); // Do proper error handling here
-///
-/// let dust_code = "one + two + three; one - two - three;";
-///
-/// assert_eq!(
-///     eval_with_context(dust_code, &mut context),
-///     vec![Ok(Value::from(6)), Ok(Value::from(-4))]
-/// );
+/// assert_eq!(eval_with_context("one + two + three", &mut context), Ok(Value::from(6)));
 /// ```
-pub fn eval_with_context(source: &str, context: &mut VariableMap) -> Vec<Result<Value>> {
+pub fn eval_with_context(source: &str, context: &mut VariableMap) -> Result<Value> {
     let mut parser = Parser::new();
 
     parser.set_language(language()).unwrap();
 
     let tree = parser.parse(source, None).unwrap();
     let sexp = tree.root_node().to_sexp();
-    let evaluator = Evaluator::new(tree.clone(), source).unwrap();
-    let mut cursor = tree.walk();
-    let results = evaluator.run(context, &mut cursor, source);
 
     println!("{sexp}");
+
+    let evaluator = Evaluator::new(tree.clone(), source).unwrap();
+    let mut cursor = tree.walk();
+
+    let results = evaluator.run(context, &mut cursor, source);
+
     println!("{evaluator:?}");
     println!("{results:?}");
-    println!("{context:?}");
 
-    results
+    Ok(Value::Empty)
 }
 
 #[derive(Debug)]
@@ -113,8 +109,7 @@ impl Item {
 
             Ok(Item::Comment(value_string.to_string()))
         } else if node.kind() == "statement" {
-            let child = node.child(0).unwrap();
-            Ok(Item::Statement(Statement::new(child, source)?))
+            Ok(Item::Statement(Statement::new(node, source)?))
         } else {
             Err(Error::UnexpectedSourceNode {
                 expected: "comment or statement",
@@ -127,20 +122,20 @@ impl Item {
 #[derive(Debug)]
 enum Statement {
     Closed(Expression),
-    Open(Expression),
 }
 
 impl Statement {
     fn new(node: Node, source: &str) -> Result<Self> {
-        let child = node.child(0).unwrap();
-
-        match node.kind() {
-            "closed_statement" => Ok(Statement::Closed(Expression::new(child, source)?)),
-            "open_statement" => Ok(Self::Open(Expression::new(child, source)?)),
-            _ => Err(Error::UnexpectedSourceNode {
-                expected: "closed_statement or open_statement",
+        if node.kind() == "statement" {
+            Ok(Statement::Closed(Expression::new(
+                node.child(0).unwrap(),
+                source,
+            )?))
+        } else {
+            Err(Error::UnexpectedSourceNode {
+                expected: "statement",
                 actual: node.kind(),
-            }),
+            })
         }
     }
 
@@ -151,19 +146,14 @@ impl Statement {
         source: &str,
     ) -> Result<Value> {
         match self {
-            Statement::Closed(expression) => {
-                expression.run(context, &mut cursor, source)?;
-
-                Ok(Value::Empty)
-            }
-            Statement::Open(expression) => expression.run(context, &mut cursor, source),
+            Statement::Closed(expression) => expression.run(context, &mut cursor, source),
         }
     }
 }
 
 #[derive(Debug)]
 enum Expression {
-    Identifier(String),
+    Identifier(&'static str),
     Value(Value),
     Operation(Operation),
 }
@@ -180,10 +170,7 @@ impl Expression {
         let child = node.child(0).unwrap();
 
         if child.kind() == "identifier" {
-            let byte_range = child.byte_range();
-            let identifier = &source[byte_range];
-
-            Ok(Self::Identifier(identifier.to_string()))
+            todo!()
         } else if child.kind() == "value" {
             Ok(Expression::Value(Value::new(child, source)?))
         } else if child.kind() == "operation" {
@@ -221,7 +208,7 @@ impl Expression {
 #[derive(Debug)]
 struct Operation {
     left: Box<Expression>,
-    operator: String,
+    operator: &'static str,
     right: Box<Expression>,
 }
 
@@ -231,7 +218,7 @@ impl Operation {
         let second_child = node.child(1).unwrap();
         let third_child = node.child(2).unwrap();
         let left = { Box::new(Expression::new(first_child, source)?) };
-        let operator = { second_child.child(0).unwrap().kind().to_string() };
+        let operator = { second_child.child(0).unwrap().kind() };
         let right = { Box::new(Expression::new(third_child, source)?) };
 
         Ok(Operation {
@@ -249,40 +236,11 @@ impl Operation {
     ) -> Result<Value> {
         let left = self.left.run(context, &mut cursor, source)?;
         let right = self.right.run(context, &mut cursor, source)?;
-        let result = match self.operator.as_str() {
+        let result = match self.operator {
             "+" => left + right,
-            "=" => {
-                if let Expression::Identifier(key) = self.left.as_ref() {
-                    context.set_value(key, right)?;
-                }
-
-                Ok(Value::Empty)
-            }
             _ => return Err(Error::CustomMessage("Operator not supported.".to_string())),
         };
 
         Ok(result?)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn evaluate_empty() {
-        assert_eq!(eval("()"), vec![Ok(Value::Empty)]);
-        assert_eq!(eval("1;"), vec![Ok(Value::Empty)]);
-        assert_eq!(eval("'foobar';"), vec![Ok(Value::Empty)]);
-    }
-
-    #[test]
-    fn evaluate_integer() {
-        assert_eq!(eval("1"), vec![Ok(Value::Integer(1))]);
-    }
-
-    #[test]
-    fn evaluate_string() {
-        assert_eq!(eval("'one'"), vec![Ok(Value::String("one".to_string()))]);
-    }
-}

src/lib.rs

@@ -7,7 +7,10 @@
 pub use crate::{
     error::*,
     interface::*,
+    operator::Operator,
+    token::PartialToken,
     tools::{Tool, ToolInfo, TOOL_LIST},
+    tree::Node,
     value::{
         function::Function, table::Table, time::Time, value_type::ValueType,
         variable_map::VariableMap, Value,
@@ -18,6 +21,9 @@ pub mod tools;
 
 mod error;
 mod interface;
+mod operator;
+mod token;
+mod tree;
 mod value;
 
 use tree_sitter::Language;

src/main.rs

@@ -32,21 +32,19 @@ fn main() {
         return run_cli_shell();
     }
 
-    let eval_results = if let Some(path) = args.path {
+    let eval_result = if let Some(path) = args.path {
         let file_contents = read_to_string(path).unwrap();
 
         eval(&file_contents)
     } else if let Some(command) = args.command {
         eval(&command)
     } else {
-        vec![Ok(Value::Empty)]
+        Ok(Value::Empty)
     };
 
-    for result in eval_results {
-        match result {
-            Ok(value) => println!("{value}"),
-            Err(error) => eprintln!("{error}"),
-        }
+    match eval_result {
+        Ok(value) => println!("{value}"),
+        Err(error) => eprintln!("{error}"),
     }
 }
 
@@ -149,13 +147,11 @@ fn run_cli_shell() {
 
                 rl.add_history_entry(line).unwrap();
 
-                let eval_results = eval_with_context(line, &mut context);
+                let eval_result = eval_with_context(line, &mut context);
 
-                for result in eval_results {
-                    match result {
-                        Ok(value) => println!("{value}"),
-                        Err(error) => eprintln!("{error}"),
-                    }
+                match eval_result {
+                    Ok(value) => println!("{value}"),
+                    Err(error) => eprintln!("{error}"),
                 }
             }
             Err(ReadlineError::Interrupted) => {

src/operator.rs

@@ -0,0 +1,547 @@
+use std::fmt::{self, Display, Formatter};
+
+use crate::{error::*, value::Value, Result, VariableMap};
+
+/// An enum that represents operators in the operator tree.
+#[derive(Debug, PartialEq, Clone)]
+pub enum Operator {
+    /// A root node in the operator tree.
+    /// The whole expression is stored under a root node, as well as each subexpression surrounded by parentheses.
+    RootNode,
+
+    /// A binary addition operator.
+    Add,
+    /// A binary subtraction operator.
+    Sub,
+    /// A unary negation operator.
+    Neg,
+    /// A binary multiplication operator.
+    Mul,
+    /// A binary division operator.
+    Div,
+    /// A binary modulo operator.
+    Mod,
+    /// A binary exponentiation operator.
+    Exp,
+
+    /// A binary equality comparator.
+    Eq,
+    /// A binary inequality comparator.
+    Neq,
+    /// A binary greater-than comparator.
+    Gt,
+    /// A binary lower-than comparator.
+    Lt,
+    /// A binary greater-than-or-equal comparator.
+    Geq,
+    /// A binary lower-than-or-equal comparator.
+    Leq,
+    /// A binary logical and operator.
+    And,
+    /// A binary logical or operator.
+    Or,
+    /// A binary logical not operator.
+    Not,
+
+    /// A binary assignment operator.
+    Assign,
+    /// A binary add-assign operator.
+    AddAssign,
+    /// A binary subtract-assign operator.
+    SubAssign,
+    /// A binary multiply-assign operator.
+    MulAssign,
+    /// A binary divide-assign operator.
+    DivAssign,
+    /// A binary modulo-assign operator.
+    ModAssign,
+    /// A binary exponentiate-assign operator.
+    ExpAssign,
+    /// A binary and-assign operator.
+    AndAssign,
+    /// A binary or-assign operator.
+    OrAssign,
+
+    /// An n-ary tuple constructor.
+    Tuple,
+    /// An n-ary subexpression chain.
+    Chain,
+
+    /// A constant value.
+    Const {
+        /** The value of the constant. */
+        value: Value,
+    },
+    /// A write to a variable identifier.
+    VariableIdentifierWrite {
+        /// The identifier of the variable.
+        identifier: String,
+    },
+    /// A read from a variable identifier.
+    VariableIdentifierRead {
+        /// The identifier of the variable.
+        identifier: String,
+    },
+    /// A function identifier.
+    FunctionIdentifier {
+        /// The identifier of the function.
+        identifier: String,
+    },
+}
+
+impl Operator {
+    pub(crate) fn value(value: Value) -> Self {
+        Operator::Const { value }
+    }
+
+    pub(crate) fn variable_identifier_write(identifier: String) -> Self {
+        Operator::VariableIdentifierWrite { identifier }
+    }
+
+    pub(crate) fn variable_identifier_read(identifier: String) -> Self {
+        Operator::VariableIdentifierRead { identifier }
+    }
+
+    pub(crate) fn function_identifier(identifier: String) -> Self {
+        Operator::FunctionIdentifier { identifier }
+    }
+
+    /// Returns the precedence of the operator.
+    /// A high precedence means that the operator has priority to be deeper in the tree.
+    pub(crate) const fn precedence(&self) -> i32 {
+        use crate::operator::Operator::*;
+        match self {
+            RootNode => 200,
+
+            Add | Sub => 95,
+            Neg => 110,
+            Mul | Div | Mod => 100,
+            Exp => 120,
+
+            Eq | Neq | Gt | Lt | Geq | Leq => 80,
+            And => 75,
+            Or => 70,
+            Not => 110,
+
+            Assign | AddAssign | SubAssign | MulAssign | DivAssign | ModAssign | ExpAssign
+            | AndAssign | OrAssign => 50,
+
+            Tuple => 40,
+            Chain => 0,
+
+            Const { .. } => 200,
+            VariableIdentifierWrite { .. } | VariableIdentifierRead { .. } => 200,
+            FunctionIdentifier { .. } => 190,
+        }
+    }
+
+    /// Returns true if chains of operators with the same precedence as this one should be evaluated left-to-right,
+    /// and false if they should be evaluated right-to-left.
+    /// Left-to-right chaining has priority if operators with different order but same precedence are chained.
+    pub(crate) const fn is_left_to_right(&self) -> bool {
+        use crate::operator::Operator::*;
+        !matches!(self, Assign | FunctionIdentifier { .. })
+    }
+
+    /// Returns true if chains of this operator should be flattened into one operator with many arguments.
+    pub(crate) const fn is_sequence(&self) -> bool {
+        use crate::operator::Operator::*;
+        matches!(self, Tuple | Chain)
+    }
+
+    /// True if this operator is a leaf, meaning it accepts no arguments.
+    // Make this a const fn as soon as whatever is missing gets stable (issue #57563)
+    pub(crate) fn is_leaf(&self) -> bool {
+        self.max_argument_amount() == Some(0)
+    }
+
+    /// Returns the maximum amount of arguments required by this operator.
+    pub(crate) const fn max_argument_amount(&self) -> Option<usize> {
+        use crate::operator::Operator::*;
+        match self {
+            Add | Sub | Mul | Div | Mod | Exp | Eq | Neq | Gt | Lt | Geq | Leq | And | Or
+            | Assign | AddAssign | SubAssign | MulAssign | DivAssign | ModAssign | ExpAssign
+            | AndAssign | OrAssign => Some(2),
+            Tuple | Chain => None,
+            Not | Neg | RootNode => Some(1),
+            Const { .. } => Some(0),
+            VariableIdentifierWrite { .. } | VariableIdentifierRead { .. } => Some(0),
+            FunctionIdentifier { .. } => Some(1),
+        }
+    }
+
+    /// Returns true if this operator is unary, i.e. it requires exactly one argument.
+    pub(crate) fn is_unary(&self) -> bool {
+        self.max_argument_amount() == Some(1) && *self != Operator::RootNode
+    }
+
+    /// Evaluates the operator with the given arguments and context.
+    pub(crate) fn eval(&self, arguments: &[Value], context: &VariableMap) -> Result<Value> {
+        use crate::operator::Operator::*;
+
+        match self {
+            RootNode => {
+                if let Some(first) = arguments.first() {
+                    Ok(first.clone())
+                } else {
+                    Ok(Value::Empty)
+                }
+            }
+            Add => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                expect_number_or_string(&arguments[0])?;
+                expect_number_or_string(&arguments[1])?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_string(), arguments[1].as_string()) {
+                    let mut result = String::with_capacity(a.len() + b.len());
+                    result.push_str(a);
+                    result.push_str(b);
+                    Ok(Value::String(result))
+                } else if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    let result = a.checked_add(b);
+                    if let Some(result) = result {
+                        Ok(Value::Integer(result))
+                    } else {
+                        Err(Error::addition_error(
+                            arguments[0].clone(),
+                            arguments[1].clone(),
+                        ))
+                    }
+                } else if let (Ok(a), Ok(b)) = (arguments[0].as_number(), arguments[1].as_number())
+                {
+                    Ok(Value::Float(a + b))
+                } else {
+                    Err(Error::wrong_type_combination(
+                        self.clone(),
+                        vec![
+                            arguments.get(0).unwrap().into(),
+                            arguments.get(1).unwrap().into(),
+                        ],
+                    ))
+                }
+            }
+            Sub => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                arguments[0].as_number()?;
+                arguments[1].as_number()?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    let result = a.checked_sub(b);
+                    if let Some(result) = result {
+                        Ok(Value::Integer(result))
+                    } else {
+                        Err(Error::subtraction_error(
+                            arguments[0].clone(),
+                            arguments[1].clone(),
+                        ))
+                    }
+                } else {
+                    Ok(Value::Float(
+                        arguments[0].as_number()? - arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Neg => {
+                Error::expect_operator_argument_amount(arguments.len(), 1)?;
+                arguments[0].as_number()?;
+
+                if let Ok(a) = arguments[0].as_int() {
+                    let result = a.checked_neg();
+                    if let Some(result) = result {
+                        Ok(Value::Integer(result))
+                    } else {
+                        Err(Error::negation_error(arguments[0].clone()))
+                    }
+                } else {
+                    Ok(Value::Float(-arguments[0].as_number()?))
+                }
+            }
+            Mul => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                arguments[0].as_number()?;
+                arguments[1].as_number()?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    let result = a.checked_mul(b);
+                    if let Some(result) = result {
+                        Ok(Value::Integer(result))
+                    } else {
+                        Err(Error::multiplication_error(
+                            arguments[0].clone(),
+                            arguments[1].clone(),
+                        ))
+                    }
+                } else {
+                    Ok(Value::Float(
+                        arguments[0].as_number()? * arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Div => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                arguments[0].as_number()?;
+                arguments[1].as_number()?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    let result = a.checked_div(b);
+                    if let Some(result) = result {
+                        Ok(Value::Integer(result))
+                    } else {
+                        Err(Error::division_error(
+                            arguments[0].clone(),
+                            arguments[1].clone(),
+                        ))
+                    }
+                } else {
+                    Ok(Value::Float(
+                        arguments[0].as_number()? / arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Mod => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                arguments[0].as_number()?;
+                arguments[1].as_number()?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    let result = a.checked_rem(b);
+                    if let Some(result) = result {
+                        Ok(Value::Integer(result))
+                    } else {
+                        Err(Error::modulation_error(
+                            arguments[0].clone(),
+                            arguments[1].clone(),
+                        ))
+                    }
+                } else {
+                    Ok(Value::Float(
+                        arguments[0].as_number()? % arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Exp => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                arguments[0].as_number()?;
+                arguments[1].as_number()?;
+
+                Ok(Value::Float(
+                    arguments[0].as_number()?.powf(arguments[1].as_number()?),
+                ))
+            }
+            Eq => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+
+                Ok(Value::Boolean(arguments[0] == arguments[1]))
+            }
+            Neq => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+
+                Ok(Value::Boolean(arguments[0] != arguments[1]))
+            }
+            Gt => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                expect_number_or_string(&arguments[0])?;
+                expect_number_or_string(&arguments[1])?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_string(), arguments[1].as_string()) {
+                    Ok(Value::Boolean(a > b))
+                } else if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    Ok(Value::Boolean(a > b))
+                } else {
+                    Ok(Value::Boolean(
+                        arguments[0].as_number()? > arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Lt => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                expect_number_or_string(&arguments[0])?;
+                expect_number_or_string(&arguments[1])?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_string(), arguments[1].as_string()) {
+                    Ok(Value::Boolean(a < b))
+                } else if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    Ok(Value::Boolean(a < b))
+                } else {
+                    Ok(Value::Boolean(
+                        arguments[0].as_number()? < arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Geq => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                expect_number_or_string(&arguments[0])?;
+                expect_number_or_string(&arguments[1])?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_string(), arguments[1].as_string()) {
+                    Ok(Value::Boolean(a >= b))
+                } else if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    Ok(Value::Boolean(a >= b))
+                } else {
+                    Ok(Value::Boolean(
+                        arguments[0].as_number()? >= arguments[1].as_number()?,
+                    ))
+                }
+            }
+            Leq => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                expect_number_or_string(&arguments[0])?;
+                expect_number_or_string(&arguments[1])?;
+
+                if let (Ok(a), Ok(b)) = (arguments[0].as_string(), arguments[1].as_string()) {
+                    Ok(Value::Boolean(a <= b))
+                } else if let (Ok(a), Ok(b)) = (arguments[0].as_int(), arguments[1].as_int()) {
+                    Ok(Value::Boolean(a <= b))
+                } else {
+                    Ok(Value::Boolean(
+                        arguments[0].as_number()? <= arguments[1].as_number()?,
+                    ))
+                }
+            }
+            And => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                let a = arguments[0].as_boolean()?;
+                let b = arguments[1].as_boolean()?;
+
+                Ok(Value::Boolean(a && b))
+            }
+            Or => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                let a = arguments[0].as_boolean()?;
+                let b = arguments[1].as_boolean()?;
+
+                Ok(Value::Boolean(a || b))
+            }
+            Not => {
+                Error::expect_operator_argument_amount(arguments.len(), 1)?;
+                let a = arguments[0].as_boolean()?;
+
+                Ok(Value::Boolean(!a))
+            }
+            Assign | AddAssign | SubAssign | MulAssign | DivAssign | ModAssign | ExpAssign
+            | AndAssign | OrAssign => Err(Error::ContextNotMutable),
+            Tuple => Ok(Value::List(arguments.into())),
+            Chain => {
+                if arguments.is_empty() {
+                    return Err(Error::expect_operator_argument_amount(0, 1).unwrap_err());
+                }
+
+                Ok(arguments.last().cloned().unwrap_or(Value::Empty))
+            }
+            Const { value } => {
+                Error::expect_operator_argument_amount(arguments.len(), 0)?;
+
+                Ok(value.clone())
+            }
+            VariableIdentifierWrite { identifier } => {
+                Error::expect_operator_argument_amount(arguments.len(), 0)?;
+
+                Ok(identifier.clone().into())
+            }
+            VariableIdentifierRead { identifier } => {
+                Error::expect_operator_argument_amount(arguments.len(), 0)?;
+
+                if let Some(value) = context.get_value(identifier)? {
+                    Ok(value)
+                } else {
+                    Err(Error::VariableIdentifierNotFound(identifier.clone()))
+                }
+            }
+            FunctionIdentifier { identifier } => {
+                Error::expect_operator_argument_amount(arguments.len(), 1)?;
+                let arguments = &arguments[0];
+
+                context.call_function(identifier, arguments)
+            }
+        }
+    }
+
+    /// Evaluates the operator with the given arguments and mutable context.
+    pub(crate) fn eval_mut(&self, arguments: &[Value], context: &mut VariableMap) -> Result<Value> {
+        use crate::operator::Operator::*;
+        match self {
+            Assign => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+                let target = arguments[0].as_string()?;
+                context.set_value(target, arguments[1].clone())?;
+
+                Ok(Value::Empty)
+            }
+            AddAssign | SubAssign | MulAssign | DivAssign | ModAssign | ExpAssign | AndAssign
+            | OrAssign => {
+                Error::expect_operator_argument_amount(arguments.len(), 2)?;
+
+                let target = arguments[0].as_string()?;
+                let left_value = Operator::VariableIdentifierRead {
+                    identifier: target.clone(),
+                }
+                .eval(&Vec::new(), context)?;
+                let arguments = vec![left_value, arguments[1].clone()];
+
+                let result = match self {
+                    AddAssign => Operator::Add.eval(&arguments, context),
+                    SubAssign => Operator::Sub.eval(&arguments, context),
+                    MulAssign => Operator::Mul.eval(&arguments, context),
+                    DivAssign => Operator::Div.eval(&arguments, context),
+                    ModAssign => Operator::Mod.eval(&arguments, context),
+                    ExpAssign => Operator::Exp.eval(&arguments, context),
+                    AndAssign => Operator::And.eval(&arguments, context),
+                    OrAssign => Operator::Or.eval(&arguments, context),
+                    _ => unreachable!(
+                        "Forgot to add a match arm for an assign operation: {}",
+                        self
+                    ),
+                }?;
+                context.set_value(target, result)?;
+
+                Ok(Value::Empty)
+            }
+            _ => self.eval(arguments, context),
+        }
+    }
+}
+
+impl Display for Operator {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        use crate::operator::Operator::*;
+        match self {
+            RootNode => Ok(()),
+            Add => write!(f, "+"),
+            Sub => write!(f, "-"),
+            Neg => write!(f, "-"),
+            Mul => write!(f, "*"),
+            Div => write!(f, "/"),
+            Mod => write!(f, "%"),
+            Exp => write!(f, "^"),
+
+            Eq => write!(f, "=="),
+            Neq => write!(f, "!="),
+            Gt => write!(f, ">"),
+            Lt => write!(f, "<"),
+            Geq => write!(f, ">="),
+            Leq => write!(f, "<="),
+            And => write!(f, "&&"),
+            Or => write!(f, "||"),
+            Not => write!(f, "!"),
+
+            Assign => write!(f, " = "),
+            AddAssign => write!(f, " += "),
+            SubAssign => write!(f, " -= "),
+            MulAssign => write!(f, " *= "),
+            DivAssign => write!(f, " /= "),
+            ModAssign => write!(f, " %= "),
+            ExpAssign => write!(f, " ^= "),
+            AndAssign => write!(f, " &&= "),
+            OrAssign => write!(f, " ||= "),
+
+            Tuple => write!(f, ", "),
+            Chain => write!(f, "; "),
+
+            Const { value } => write!(f, "{}", value),
+            VariableIdentifierWrite { identifier } | VariableIdentifierRead { identifier } => {
+                write!(f, "{}", identifier)
+            }
+            FunctionIdentifier { identifier } => write!(f, "{}", identifier),
+        }
+    }
+}

src/token.rs

@@ -0,0 +1,562 @@
+use std::fmt::{self, Display, Formatter};
+
+use crate::error::{Error, Result};
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Token {
+    // Arithmetic
+    Plus,
+    Minus,
+    Star,
+    Slash,
+    Percent,
+    Hat,
+
+    // Logic
+    Eq,
+    Neq,
+    Gt,
+    Lt,
+    Geq,
+    Leq,
+    And,
+    Or,
+    Not,
+
+    // Precedence
+    LBrace,
+    RBrace,
+
+    // Assignment
+    Assign,
+    PlusAssign,
+    MinusAssign,
+    StarAssign,
+    SlashAssign,
+    PercentAssign,
+    HatAssign,
+    AndAssign,
+    OrAssign,
+
+    // Special
+    Comma,
+    Semicolon,
+    Yield(String, String),
+
+    // Values, Variables and Functions
+    Identifier(String),
+    Float(f64),
+    Int(i64),
+    Boolean(bool),
+    String(String),
+    Function(String),
+}
+
+/// A partial token is an input character whose meaning depends on the characters around it.
+#[derive(Clone, Debug, PartialEq)]
+pub enum PartialToken {
+    /// A partial token that unambiguously maps to a single token.
+    Token(Token),
+    /// A partial token that is a literal.
+    Literal(String),
+    /// A plus character '+'.
+    Plus,
+    /// A minus character '-'.
+    Minus,
+    /// A star character '*'.
+    Star,
+    /// A slash character '/'.
+    Slash,
+    /// A percent character '%'.
+    Percent,
+    /// A hat character '^'.
+    Hat,
+    /// A whitespace character, e.g. ' '.
+    Whitespace,
+    /// An equal-to character '='.
+    Eq,
+    /// An exclamation mark character '!'.
+    ExclamationMark,
+    /// A greater-than character '>'.
+    Gt,
+    /// A lower-than character '<'.
+    Lt,
+    /// An ampersand character '&'.
+    Ampersand,
+    /// A vertical bar character '|'.
+    VerticalBar,
+}
+
+// Make this a const fn as soon as is_whitespace and to_string get stable (issue #57563)
+fn char_to_partial_token(c: char) -> PartialToken {
+    match c {
+        '+' => PartialToken::Plus,
+        '-' => PartialToken::Minus,
+        '*' => PartialToken::Star,
+        '/' => PartialToken::Slash,
+        '%' => PartialToken::Percent,
+        '^' => PartialToken::Hat,
+
+        '(' => PartialToken::Token(Token::LBrace),
+        ')' => PartialToken::Token(Token::RBrace),
+
+        ',' => PartialToken::Token(Token::Comma),
+        ';' => PartialToken::Token(Token::Semicolon),
+
+        '=' => PartialToken::Eq,
+        '!' => PartialToken::ExclamationMark,
+        '>' => PartialToken::Gt,
+        '<' => PartialToken::Lt,
+        '&' => PartialToken::Ampersand,
+        '|' => PartialToken::VerticalBar,
+
+        c => {
+            if c.is_whitespace() {
+                PartialToken::Whitespace
+            } else {
+                PartialToken::Literal(c.to_string())
+            }
+        }
+    }
+}
+
+impl Token {
+    #[cfg(not(tarpaulin_include))]
+    pub(crate) const fn is_leftsided_value(&self) -> bool {
+        match self {
+            Token::Plus => false,
+            Token::Minus => false,
+            Token::Star => false,
+            Token::Slash => false,
+            Token::Percent => false,
+            Token::Hat => false,
+
+            Token::Eq => false,
+            Token::Neq => false,
+            Token::Gt => false,
+            Token::Lt => false,
+            Token::Geq => false,
+            Token::Leq => false,
+            Token::And => false,
+            Token::Or => false,
+            Token::Not => false,
+
+            Token::LBrace => true,
+            Token::RBrace => false,
+
+            Token::Comma => false,
+            Token::Semicolon => false,
+            Token::Yield(_, _) => false,
+
+            Token::Assign => false,
+            Token::PlusAssign => false,
+            Token::MinusAssign => false,
+            Token::StarAssign => false,
+            Token::SlashAssign => false,
+            Token::PercentAssign => false,
+            Token::HatAssign => false,
+            Token::AndAssign => false,
+            Token::OrAssign => false,
+
+            Token::Identifier(_) => true,
+            Token::Float(_) => true,
+            Token::Int(_) => true,
+            Token::Boolean(_) => true,
+            Token::String(_) => true,
+            Token::Function(_) => true,
+        }
+    }
+
+    #[cfg(not(tarpaulin_include))]
+    pub(crate) const fn is_rightsided_value(&self) -> bool {
+        match self {
+            Token::Plus => false,
+            Token::Minus => false,
+            Token::Star => false,
+            Token::Slash => false,
+            Token::Percent => false,
+            Token::Hat => false,
+
+            Token::Eq => false,
+            Token::Neq => false,
+            Token::Gt => false,
+            Token::Lt => false,
+            Token::Geq => false,
+            Token::Leq => false,
+            Token::And => false,
+            Token::Or => false,
+            Token::Not => false,
+
+            Token::LBrace => false,
+            Token::RBrace => true,
+
+            Token::Comma => false,
+            Token::Semicolon => false,
+            Token::Yield(_, _) => false,
+
+            Token::Assign => false,
+            Token::PlusAssign => false,
+            Token::MinusAssign => false,
+            Token::StarAssign => false,
+            Token::SlashAssign => false,
+            Token::PercentAssign => false,
+            Token::HatAssign => false,
+            Token::AndAssign => false,
+            Token::OrAssign => false,
+
+            Token::Identifier(_) => true,
+            Token::Float(_) => true,
+            Token::Int(_) => true,
+            Token::Boolean(_) => true,
+            Token::String(_) => true,
+            Token::Function(_) => true,
+        }
+    }
+
+    #[cfg(not(tarpaulin_include))]
+    pub(crate) fn is_assignment(&self) -> bool {
+        use Token::*;
+        matches!(
+            self,
+            Assign
+                | PlusAssign
+                | MinusAssign
+                | StarAssign
+                | SlashAssign
+                | PercentAssign
+                | HatAssign
+                | AndAssign
+                | OrAssign
+        )
+    }
+}
+
+/// Parses an escape sequence within a string literal.
+fn parse_escape_sequence<Iter: Iterator<Item = char>>(iter: &mut Iter) -> Result<char> {
+    match iter.next() {
+        Some('"') => Ok('"'),
+        Some('\\') => Ok('\\'),
+        Some(c) => Err(Error::IllegalEscapeSequence(format!("\\{}", c))),
+        None => Err(Error::IllegalEscapeSequence("\\".to_string())),
+    }
+}
+
+/// Parses a string value from the given character iterator.
+///
+/// The first character from the iterator is interpreted as first character of the string.
+/// The string is terminated by a double quote `"`.
+/// Occurrences of `"` within the string can be escaped with `\`.
+/// The backslash needs to be escaped with another backslash `\`.
+fn parse_string_literal<Iter: Iterator<Item = char>>(mut iter: &mut Iter) -> Result<PartialToken> {
+    let mut result = String::new();
+
+    while let Some(c) = iter.next() {
+        match c {
+            '"' => break,
+            '\\' => result.push(parse_escape_sequence(&mut iter)?),
+            c => result.push(c),
+        }
+    }
+
+    Ok(PartialToken::Token(Token::String(result)))
+}
+
+fn parse_function<Iter: Iterator<Item = char>>(mut iter: &mut Iter) -> Result<PartialToken> {
+    let mut result = String::new();
+
+    while let Some(c) = iter.next() {
+        match c {
+            '\'' => break,
+            '\\' => result.push(parse_escape_sequence(&mut iter)?),
+            c => result.push(c),
+        }
+    }
+
+    Ok(PartialToken::Token(Token::Function(result)))
+}
+
+/// Converts a string to a vector of partial tokens.
+fn str_to_partial_tokens(string: &str) -> Result<Vec<PartialToken>> {
+    let mut result = Vec::new();
+    let mut iter = string.chars().peekable();
+
+    while let Some(c) = iter.next() {
+        if c == '"' {
+            result.push(parse_string_literal(&mut iter)?);
+        } else if c == '\'' {
+            result.push(parse_function(&mut iter)?)
+        } else {
+            let partial_token = char_to_partial_token(c);
+
+            let if_let_successful =
+                if let (Some(PartialToken::Literal(last)), PartialToken::Literal(literal)) =
+                    (result.last_mut(), &partial_token)
+                {
+                    last.push_str(literal);
+                    true
+                } else {
+                    false
+                };
+
+            if !if_let_successful {
+                result.push(partial_token);
+            }
+        }
+    }
+    Ok(result)
+}
+
+/// Resolves all partial tokens by converting them to complex tokens.
+fn partial_tokens_to_tokens(mut tokens: &[PartialToken]) -> Result<Vec<Token>> {
+    let mut result = Vec::new();
+    while !tokens.is_empty() {
+        let first = tokens[0].clone();
+        let second = tokens.get(1).cloned();
+        let third = tokens.get(2).cloned();
+        let mut cutoff = 2;
+
+        result.extend(
+            match first {
+                PartialToken::Token(token) => {
+                    cutoff = 1;
+                    Some(token)
+                }
+                PartialToken::Plus => match second {
+                    Some(PartialToken::Eq) => Some(Token::PlusAssign),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Plus)
+                    }
+                },
+                PartialToken::Minus => match second {
+                    Some(PartialToken::Eq) => Some(Token::MinusAssign),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Minus)
+                    }
+                },
+                PartialToken::Star => match second {
+                    Some(PartialToken::Eq) => Some(Token::StarAssign),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Star)
+                    }
+                },
+                PartialToken::Slash => match second {
+                    Some(PartialToken::Eq) => Some(Token::SlashAssign),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Slash)
+                    }
+                },
+                PartialToken::Percent => match second {
+                    Some(PartialToken::Eq) => Some(Token::PercentAssign),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Percent)
+                    }
+                },
+                PartialToken::Hat => match second {
+                    Some(PartialToken::Eq) => Some(Token::HatAssign),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Hat)
+                    }
+                },
+                PartialToken::Literal(literal) => {
+                    cutoff = 1;
+                    if let Ok(number) = parse_dec_or_hex(&literal) {
+                        Some(Token::Int(number))
+                    } else if let Ok(number) = literal.parse::<f64>() {
+                        Some(Token::Float(number))
+                    } else if let Ok(boolean) = literal.parse::<bool>() {
+                        Some(Token::Boolean(boolean))
+                    } else {
+                        // If there are two tokens following this one, check if the next one is
+                        // a plus or a minus. If so, then attempt to parse all three tokens as a
+                        // scientific notation number of the form `<coefficient>e{+,-}<exponent>`,
+                        // for example [Literal("10e"), Minus, Literal("3")] => "1e-3".parse().
+                        match (second, third) {
+                            (Some(second), Some(third))
+                                if second == PartialToken::Minus
+                                    || second == PartialToken::Plus =>
+                            {
+                                if let Ok(number) =
+                                    format!("{}{}{}", literal, second, third).parse::<f64>()
+                                {
+                                    cutoff = 3;
+                                    Some(Token::Float(number))
+                                } else {
+                                    Some(Token::Identifier(literal.to_string()))
+                                }
+                            }
+                            _ => Some(Token::Identifier(literal.to_string())),
+                        }
+                    }
+                }
+                PartialToken::Whitespace => {
+                    cutoff = 1;
+                    None
+                }
+                PartialToken::Eq => match second {
+                    Some(PartialToken::Eq) => Some(Token::Eq),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Assign)
+                    }
+                },
+                PartialToken::ExclamationMark => match second {
+                    Some(PartialToken::Eq) => Some(Token::Neq),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Not)
+                    }
+                },
+                PartialToken::Gt => match second {
+                    Some(PartialToken::Eq) => Some(Token::Geq),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Gt)
+                    }
+                },
+                PartialToken::Lt => match second {
+                    Some(PartialToken::Eq) => Some(Token::Leq),
+                    _ => {
+                        cutoff = 1;
+                        Some(Token::Lt)
+                    }
+                },
+                PartialToken::Ampersand => match second {
+                    Some(PartialToken::Ampersand) => match third {
+                        Some(PartialToken::Eq) => {
+                            cutoff = 3;
+                            Some(Token::AndAssign)
+                        }
+                        _ => Some(Token::And),
+                    },
+                    _ => return Err(Error::unmatched_partial_token(first, second)),
+                },
+                PartialToken::VerticalBar => match second {
+                    Some(PartialToken::VerticalBar) => match third {
+                        Some(PartialToken::Eq) => {
+                            cutoff = 3;
+                            Some(Token::OrAssign)
+                        }
+                        _ => Some(Token::Or),
+                    },
+                    _ => return Err(Error::unmatched_partial_token(first, second)),
+                },
+            }
+            .into_iter(),
+        );
+
+        tokens = &tokens[cutoff..];
+    }
+    Ok(result)
+}
+
+impl Display for Token {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        use self::Token::*;
+        match self {
+            Plus => write!(f, "+"),
+            Minus => write!(f, "-"),
+            Star => write!(f, "*"),
+            Slash => write!(f, "/"),
+            Percent => write!(f, "%"),
+            Hat => write!(f, "^"),
+
+            // Logic
+            Eq => write!(f, "=="),
+            Neq => write!(f, "!="),
+            Gt => write!(f, ">"),
+            Lt => write!(f, "<"),
+            Geq => write!(f, ">="),
+            Leq => write!(f, "<="),
+            And => write!(f, "&&"),
+            Or => write!(f, "||"),
+            Not => write!(f, "!"),
+
+            // Precedence
+            LBrace => write!(f, "("),
+            RBrace => write!(f, ")"),
+
+            // Assignment
+            Assign => write!(f, "="),
+            PlusAssign => write!(f, "+="),
+            MinusAssign => write!(f, "-="),
+            StarAssign => write!(f, "*="),
+            SlashAssign => write!(f, "/="),
+            PercentAssign => write!(f, "%="),
+            HatAssign => write!(f, "^="),
+            AndAssign => write!(f, "&&="),
+            OrAssign => write!(f, "||="),
+
+            // Special
+            Comma => write!(f, ","),
+            Semicolon => write!(f, ";"),
+
+            // Values => write!(f, ""), Variables and Functions
+            Identifier(identifier) => identifier.fmt(f),
+            Float(float) => float.fmt(f),
+            Int(int) => int.fmt(f),
+            Boolean(boolean) => boolean.fmt(f),
+            String(string) => fmt::Debug::fmt(string, f),
+            Function(string) => write!(f, "'{string}'"),
+            Yield(_, _) => todo!(),
+        }
+    }
+}
+
+impl Display for PartialToken {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        use self::PartialToken::*;
+        match self {
+            Token(token) => token.fmt(f),
+            Literal(literal) => literal.fmt(f),
+            Whitespace => write!(f, " "),
+            Plus => write!(f, "+"),
+            Minus => write!(f, "-"),
+            Star => write!(f, "*"),
+            Slash => write!(f, "/"),
+            Percent => write!(f, "%"),
+            Hat => write!(f, "^"),
+            Eq => write!(f, "="),
+            ExclamationMark => write!(f, "!"),
+            Gt => write!(f, ">"),
+            Lt => write!(f, "<"),
+            Ampersand => write!(f, "&"),
+            VerticalBar => write!(f, "|"),
+        }
+    }
+}
+
+pub(crate) fn tokenize(string: &str) -> Result<Vec<Token>> {
+    partial_tokens_to_tokens(&str_to_partial_tokens(string)?)
+}
+
+fn parse_dec_or_hex(literal: &str) -> std::result::Result<i64, std::num::ParseIntError> {
+    if let Some(literal) = literal.strip_prefix("0x") {
+        literal.parse()
+    } else {
+        literal.parse()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::token::{tokenize, Token};
+
+    #[test]
+    fn assignment_lhs_is_identifier() {
+        let tokens = tokenize("a = 1").unwrap();
+        assert_eq!(
+            tokens.as_slice(),
+            [
+                Token::Identifier("a".to_string()),
+                Token::Assign,
+                Token::Int(1)
+            ]
+        );
+    }
+}

src/tools/gui.rs

@@ -233,7 +233,8 @@ impl eframe::App for GuiApp {
                         }
 
                         if submit.clicked() {
-                            todo!()
+                            self.eval_result =
+                                eval_with_context(&self.text_edit_buffer, &mut self.whale_context);
                         }
                     });
                 },

src/tree/iter.rs

@@ -0,0 +1,94 @@
+use crate::{operator::Operator, Node};
+use std::slice::{Iter, IterMut};
+
+/// An iterator that traverses an operator tree in pre-order.
+pub struct NodeIter<'a> {
+    stack: Vec<Iter<'a, Node>>,
+}
+
+impl<'a> NodeIter<'a> {
+    fn new(node: &'a Node) -> Self {
+        NodeIter {
+            stack: vec![node.children.iter()],
+        }
+    }
+}
+
+impl<'a> Iterator for NodeIter<'a> {
+    type Item = &'a Node;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let mut result = None;
+
+            if let Some(last) = self.stack.last_mut() {
+                if let Some(next) = last.next() {
+                    result = Some(next);
+                } else {
+                    // Can not fail because we just borrowed last.
+                    // We just checked that the iterator is empty, so we can safely discard it.
+                    let _ = self.stack.pop().unwrap();
+                }
+            } else {
+                return None;
+            }
+
+            if let Some(result) = result {
+                self.stack.push(result.children.iter());
+                return Some(result);
+            }
+        }
+    }
+}
+
+/// An iterator that mutably traverses an operator tree in pre-order.
+pub struct OperatorIterMut<'a> {
+    stack: Vec<IterMut<'a, Node>>,
+}
+
+impl<'a> OperatorIterMut<'a> {
+    fn new(node: &'a mut Node) -> Self {
+        OperatorIterMut {
+            stack: vec![node.children.iter_mut()],
+        }
+    }
+}
+
+impl<'a> Iterator for OperatorIterMut<'a> {
+    type Item = &'a mut Operator;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let mut result = None;
+
+            if let Some(last) = self.stack.last_mut() {
+                if let Some(next) = last.next() {
+                    result = Some(next);
+                } else {
+                    // Can not fail because we just borrowed last.
+                    // We just checked that the iterator is empty, so we can safely discard it.
+                    let _ = self.stack.pop().unwrap();
+                }
+            } else {
+                return None;
+            }
+
+            if let Some(result) = result {
+                self.stack.push(result.children.iter_mut());
+                return Some(&mut result.operator);
+            }
+        }
+    }
+}
+
+impl Node {
+    /// Returns an iterator over all nodes in this tree.
+    pub fn iter(&self) -> impl Iterator<Item = &Node> {
+        NodeIter::new(self)
+    }
+
+    /// Returns a mutable iterator over all operators in this tree.
+    pub fn iter_operators_mut(&mut self) -> impl Iterator<Item = &mut Operator> {
+        OperatorIterMut::new(self)
+    }
+}

src/tree/mod.rs

@@ -0,0 +1,691 @@
+use crate::Function;
+use crate::{token::Token, VariableMap};
+
+use crate::{
+    error::{Error, Result},
+    operator::*,
+    value::Value,
+};
+use std::{
+    fmt::{self, Display, Formatter},
+    mem,
+};
+
+#[cfg(not(tarpaulin_include))]
+mod iter;
+
+/// A node in the operator tree.
+/// The operator tree is created by the crate-level `build_operator_tree` method.
+/// It can be evaluated for a given context with the `Node::eval` method.
+///
+/// The advantage of constructing the operator tree separately from the actual evaluation is that it can be evaluated arbitrarily often with different contexts.
+#[derive(Debug, PartialEq, Clone)]
+pub struct Node {
+    operator: Operator,
+    children: Vec<Node>,
+}
+
+impl Node {
+    fn new(operator: Operator) -> Self {
+        Self {
+            children: Vec::new(),
+            operator,
+        }
+    }
+
+    fn root_node() -> Self {
+        Self::new(Operator::RootNode)
+    }
+
+    pub fn iter_identifiers(&self) -> impl Iterator<Item = &str> {
+        self.iter().filter_map(|node| match node.operator() {
+            Operator::VariableIdentifierWrite { identifier }
+            | Operator::VariableIdentifierRead { identifier }
+            | Operator::FunctionIdentifier { identifier } => Some(identifier.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Returns an iterator over all identifiers in this expression, allowing mutation.
+    /// Each occurrence of an identifier is returned separately.
+    pub fn iter_identifiers_mut(&mut self) -> impl Iterator<Item = &mut String> {
+        self.iter_operators_mut()
+            .filter_map(|operator| match operator {
+                Operator::VariableIdentifierWrite { identifier }
+                | Operator::VariableIdentifierRead { identifier }
+                | Operator::FunctionIdentifier { identifier } => Some(identifier),
+                _ => None,
+            })
+    }
+
+    /// Returns an iterator over all variable identifiers in this expression.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_variable_identifiers(&self) -> impl Iterator<Item = &str> {
+        self.iter().filter_map(|node| match node.operator() {
+            Operator::VariableIdentifierWrite { identifier }
+            | Operator::VariableIdentifierRead { identifier } => Some(identifier.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Returns an iterator over all variable identifiers in this expression, allowing mutation.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_variable_identifiers_mut(&mut self) -> impl Iterator<Item = &mut String> {
+        self.iter_operators_mut()
+            .filter_map(|operator| match operator {
+                Operator::VariableIdentifierWrite { identifier }
+                | Operator::VariableIdentifierRead { identifier } => Some(identifier),
+                _ => None,
+            })
+    }
+
+    /// Returns an iterator over all read variable identifiers in this expression.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_read_variable_identifiers(&self) -> impl Iterator<Item = &str> {
+        self.iter().filter_map(|node| match node.operator() {
+            Operator::VariableIdentifierRead { identifier } => Some(identifier.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Returns an iterator over all read variable identifiers in this expression, allowing mutation.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_read_variable_identifiers_mut(&mut self) -> impl Iterator<Item = &mut String> {
+        self.iter_operators_mut()
+            .filter_map(|operator| match operator {
+                Operator::VariableIdentifierRead { identifier } => Some(identifier),
+                _ => None,
+            })
+    }
+
+    /// Returns an iterator over all write variable identifiers in this expression.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_write_variable_identifiers(&self) -> impl Iterator<Item = &str> {
+        self.iter().filter_map(|node| match node.operator() {
+            Operator::VariableIdentifierWrite { identifier } => Some(identifier.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Returns an iterator over all write variable identifiers in this expression, allowing mutation.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_write_variable_identifiers_mut(&mut self) -> impl Iterator<Item = &mut String> {
+        self.iter_operators_mut()
+            .filter_map(|operator| match operator {
+                Operator::VariableIdentifierWrite { identifier } => Some(identifier),
+                _ => None,
+            })
+    }
+
+    /// Returns an iterator over all function identifiers in this expression.
+    /// Each occurrence of a function identifier is returned separately.
+    pub fn iter_function_identifiers(&self) -> impl Iterator<Item = &str> {
+        self.iter().filter_map(|node| match node.operator() {
+            Operator::FunctionIdentifier { identifier } => Some(identifier.as_str()),
+            _ => None,
+        })
+    }
+
+    /// Returns an iterator over all function identifiers in this expression, allowing mutation.
+    /// Each occurrence of a variable identifier is returned separately.
+    pub fn iter_function_identifiers_mut(&mut self) -> impl Iterator<Item = &mut String> {
+        self.iter_operators_mut()
+            .filter_map(|operator| match operator {
+                Operator::FunctionIdentifier { identifier } => Some(identifier),
+                _ => None,
+            })
+    }
+
+    /// Evaluates the operator tree rooted at this node with the given context. Fails if one of the
+    /// operators in the expression tree fails.
+    pub fn eval_with_context(&self, context: &VariableMap) -> Result<Value> {
+        let mut arguments = Vec::new();
+        for child in self.children() {
+            arguments.push(child.eval_with_context(context)?);
+        }
+        self.operator().eval(&arguments, context)
+    }
+
+    /// Evaluates the operator tree rooted at this node with the given mutable context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_with_context_mut(&self, context: &mut VariableMap) -> Result<Value> {
+        let mut arguments = Vec::new();
+        for child in self.children() {
+            arguments.push(child.eval_with_context_mut(context)?);
+        }
+        self.operator().eval_mut(&arguments, context)
+    }
+
+    /// Evaluates the operator tree rooted at this node.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval(&self) -> Result<Value> {
+        self.eval_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into a string with an the given context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_string_with_context(&self, context: &VariableMap) -> Result<String> {
+        match self.eval_with_context(context) {
+            Ok(Value::String(string)) => Ok(string),
+            Ok(value) => Err(Error::expected_string(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a float with an the given context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_float_with_context(&self, context: &VariableMap) -> Result<f64> {
+        match self.eval_with_context(context) {
+            Ok(Value::Float(float)) => Ok(float),
+            Ok(value) => Err(Error::expected_float(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into an integer with an the given context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_int_with_context(&self, context: &VariableMap) -> Result<i64> {
+        match self.eval_with_context(context) {
+            Ok(Value::Integer(int)) => Ok(int),
+            Ok(value) => Err(Error::expected_int(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a float with an the given context. If
+    /// the result of the expression is an integer, it is silently converted into a float. Fails         /// if one of the operators in the expression tree fails.
+    pub fn eval_number_with_context(&self, context: &VariableMap) -> Result<f64> {
+        match self.eval_with_context(context) {
+            Ok(Value::Integer(int)) => Ok(int as f64),
+            Ok(Value::Float(float)) => Ok(float),
+            Ok(value) => Err(Error::expected_number(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a boolean with an the given context     
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_boolean_with_context(&self, context: &VariableMap) -> Result<bool> {
+        match self.eval_with_context(context) {
+            Ok(Value::Boolean(boolean)) => Ok(boolean),
+            Ok(value) => Err(Error::expected_boolean(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a tuple with an the given context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_tuple_with_context(&self, context: &VariableMap) -> Result<Vec<Value>> {
+        match self.eval_with_context(context) {
+            Ok(Value::List(tuple)) => Ok(tuple),
+            Ok(value) => Err(Error::expected_list(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into an empty value with an the given context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_empty_with_context(&self, context: &VariableMap) -> Result<()> {
+        match self.eval_with_context(context) {
+            Ok(Value::Empty) => Ok(()),
+            Ok(value) => Err(Error::expected_empty(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a string with an the given mutable context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_string_with_context_mut(&self, context: &mut VariableMap) -> Result<String> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::String(string)) => Ok(string),
+            Ok(value) => Err(Error::expected_string(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a float with an the given mutable context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_float_with_context_mut(&self, context: &mut VariableMap) -> Result<f64> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::Float(float)) => Ok(float),
+            Ok(value) => Err(Error::expected_float(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into an integer with an the given mutable context.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_int_with_context_mut(&self, context: &mut VariableMap) -> Result<i64> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::Integer(int)) => Ok(int),
+            Ok(value) => Err(Error::expected_int(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a float with an the given mutable context.
+    /// If the result of the expression is an integer, it is silently converted into a float.
+    /// Fails if one of the operators in the expression tree fails.
+    pub fn eval_number_with_context_mut(&self, context: &mut VariableMap) -> Result<f64> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::Integer(int)) => Ok(int as f64),
+            Ok(Value::Float(float)) => Ok(float),
+            Ok(value) => Err(Error::expected_number(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a boolean with an the given mutable         /// context. Fails if one of the operators in the expression tree fails.
+    pub fn eval_boolean_with_context_mut(&self, context: &mut VariableMap) -> Result<bool> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::Boolean(boolean)) => Ok(boolean),
+            Ok(value) => Err(Error::expected_boolean(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a tuple with an the given mutable           /// context. Fails if one of the operators in the expression tree fails.
+    pub fn eval_tuple_with_context_mut(&self, context: &mut VariableMap) -> Result<Vec<Value>> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::List(tuple)) => Ok(tuple),
+            Ok(value) => Err(Error::expected_list(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into an empty value with an the given            /// mutable context. Fails if one of the operators in the expression tree fails.
+    pub fn eval_empty_with_context_mut(&self, context: &mut VariableMap) -> Result<()> {
+        match self.eval_with_context_mut(context) {
+            Ok(Value::Empty) => Ok(()),
+            Ok(value) => Err(Error::expected_empty(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    /// Evaluates the operator tree rooted at this node into a string. Fails if one of the               /// operators in the expression tree fails.
+    pub fn eval_string(&self) -> Result<String> {
+        self.eval_string_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into a float. Fails if one of the operators      /// in the expression tree fails.
+    pub fn eval_float(&self) -> Result<f64> {
+        self.eval_float_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into an integer. Fails if one of the     
+    /// operators in the expression tree fails.
+    pub fn eval_int(&self) -> Result<i64> {
+        self.eval_int_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into a float. If the result of the     
+    /// expression is an integer, it is silently converted into a float. Fails if one of the            /// operators in the expression tree fails.
+    pub fn eval_number(&self) -> Result<f64> {
+        self.eval_number_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into a boolean. Fails if one of the             /// operators in the expression tree fails.
+    pub fn eval_boolean(&self) -> Result<bool> {
+        self.eval_boolean_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into a tuple. Fails if one of the operators     /// in the expression tree fails.
+    pub fn eval_tuple(&self) -> Result<Vec<Value>> {
+        self.eval_tuple_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Evaluates the operator tree rooted at this node into an empty value. Fails if one of the        /// operators in the expression tree fails.
+    pub fn eval_empty(&self) -> Result<()> {
+        self.eval_empty_with_context_mut(&mut VariableMap::new())
+    }
+
+    /// Returns the children of this node as a slice.
+    pub fn children(&self) -> &[Node] {
+        &self.children
+    }
+
+    /// Returns the operator associated with this node.
+    pub fn operator(&self) -> &Operator {
+        &self.operator
+    }
+
+    /// Returns a mutable reference to the vector containing the children of this node.
+    ///
+    /// WARNING: Writing to this might have unexpected results, as some operators require certain amounts and types of arguments.
+    pub fn children_mut(&mut self) -> &mut Vec<Node> {
+        &mut self.children
+    }
+
+    /// Returns a mutable reference to the operator associated with this node.
+    ///
+    /// WARNING: Writing to this might have unexpected results, as some operators require different amounts and types of arguments.
+    pub fn operator_mut(&mut self) -> &mut Operator {
+        &mut self.operator
+    }
+
+    fn has_enough_children(&self) -> bool {
+        Some(self.children().len()) == self.operator().max_argument_amount()
+    }
+
+    fn has_too_many_children(&self) -> bool {
+        if let Some(max_argument_amount) = self.operator().max_argument_amount() {
+            self.children().len() > max_argument_amount
+        } else {
+            false
+        }
+    }
+
+    fn insert_back_prioritized(&mut self, node: Node, is_root_node: bool) -> Result<()> {
+        // println!(
+        //     "Inserting {:?} into {:?}, is_root_node = {is_root_node}",
+        //     node.operator(),
+        //     self.operator()
+        // );
+        // println!("Self is {:?}", self);
+        if self.operator().precedence() < node.operator().precedence() || node.operator().is_unary() || is_root_node
+            // Right-to-left chaining
+            || (self.operator().precedence() == node.operator().precedence() && !self.operator().is_left_to_right() && !node.operator().is_left_to_right())
+        {
+            if self.operator().is_leaf() {
+                Err(Error::AppendedToLeafNode(node))
+            } else if self.has_enough_children() {
+                // Unwrap cannot fail because is_leaf being false and has_enough_children being true implies that the operator wants and has at least one child
+                let last_child_operator = self.children.last().unwrap().operator();
+
+                if last_child_operator.precedence()
+                    < node.operator().precedence() || node.operator().is_unary()
+                    // Right-to-left chaining
+                    || (last_child_operator.precedence()
+                    == node.operator().precedence() && !last_child_operator.is_left_to_right() && !node.operator().is_left_to_right())
+                {
+                    // println!(
+                    //     "Recursing into {:?}",
+                    //     self.children.last().unwrap().operator()
+                    // );
+                    // Unwrap cannot fail because is_leaf being false and has_enough_children being true implies that the operator wants and has at least one child
+                    self.children
+                        .last_mut()
+                        .unwrap()
+                        .insert_back_prioritized(node, false)
+                } else {
+                    // println!("Rotating");
+                    if node.operator().is_leaf() {
+                        return Err(Error::AppendedToLeafNode(node));
+                    }
+
+                    // Unwrap cannot fail because is_leaf being false and has_enough_children being true implies that the operator wants and has at least one child
+                    let last_child = self.children.pop().unwrap();
+                    // Root nodes have at most one child
+                    // TODO I am not sure if this is the correct error
+                    if self.operator() == &Operator::RootNode && !self.children().is_empty() {
+                        return Err(Error::MissingOperatorOutsideOfBrace);
+                    }
+                    // Do not insert root nodes into root nodes.
+                    // TODO I am not sure if this is the correct error
+                    if self.operator() == &Operator::RootNode
+                        && node.operator() == &Operator::RootNode
+                    {
+                        return Err(Error::MissingOperatorOutsideOfBrace);
+                    }
+                    self.children.push(node);
+                    let node = self.children.last_mut().unwrap();
+
+                    // Root nodes have at most one child
+                    // TODO I am not sure if this is the correct error
+                    if node.operator() == &Operator::RootNode && !node.children().is_empty() {
+                        return Err(Error::MissingOperatorOutsideOfBrace);
+                    }
+                    // Do not insert root nodes into root nodes.
+                    // TODO I am not sure if this is the correct error
+                    if node.operator() == &Operator::RootNode
+                        && last_child.operator() == &Operator::RootNode
+                    {
+                        return Err(Error::MissingOperatorOutsideOfBrace);
+                    }
+                    node.children.push(last_child);
+                    Ok(())
+                }
+            } else {
+                // println!("Inserting as specified");
+                self.children.push(node);
+                Ok(())
+            }
+        } else {
+            Err(Error::PrecedenceViolation)
+        }
+    }
+}
+
+impl Display for Node {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.operator.fmt(f)?;
+        for child in self.children() {
+            write!(f, " {}", child)?;
+        }
+        Ok(())
+    }
+}
+
+fn collapse_root_stack_to(
+    root_stack: &mut Vec<Node>,
+    mut root: Node,
+    collapse_goal: &Node,
+) -> Result<Node> {
+    loop {
+        if let Some(mut potential_higher_root) = root_stack.pop() {
+            // TODO I'm not sure about this >, as I have no example for different sequence operators with the same precedence
+            if potential_higher_root.operator().precedence() > collapse_goal.operator().precedence()
+            {
+                potential_higher_root.children.push(root);
+                root = potential_higher_root;
+            } else {
+                root_stack.push(potential_higher_root);
+                break;
+            }
+        } else {
+            // This is the only way the topmost root node could have been removed
+            return Err(Error::UnmatchedRBrace);
+        }
+    }
+
+    Ok(root)
+}
+
+fn collapse_all_sequences(root_stack: &mut Vec<Node>) -> Result<()> {
+    // println!("Collapsing all sequences");
+    // println!("Initial root stack is: {:?}", root_stack);
+    let mut root = if let Some(root) = root_stack.pop() {
+        root
+    } else {
+        return Err(Error::UnmatchedRBrace);
+    };
+
+    loop {
+        // println!("Root is: {:?}", root);
+        if root.operator() == &Operator::RootNode {
+            // This should fire if parsing something like `4(5)`
+            if root.has_too_many_children() {
+                return Err(Error::MissingOperatorOutsideOfBrace);
+            }
+
+            root_stack.push(root);
+            break;
+        }
+
+        if let Some(mut potential_higher_root) = root_stack.pop() {
+            if root.operator().is_sequence() {
+                potential_higher_root.children.push(root);
+                root = potential_higher_root;
+            } else {
+                // This should fire if parsing something like `4(5)`
+                if root.has_too_many_children() {
+                    return Err(Error::MissingOperatorOutsideOfBrace);
+                }
+
+                root_stack.push(potential_higher_root);
+                root_stack.push(root);
+                break;
+            }
+        } else {
+            // This is the only way the topmost root node could have been removed
+            return Err(Error::UnmatchedRBrace);
+        }
+    }
+
+    // println!("Root stack after collapsing all sequences is: {:?}", root_stack);
+    Ok(())
+}
+
+pub(crate) fn tokens_to_operator_tree(tokens: Vec<Token>) -> Result<Node> {
+    let mut root_stack = vec![Node::root_node()];
+    let mut last_token_is_rightsided_value = false;
+    let mut token_iter = tokens.iter().peekable();
+
+    while let Some(token) = token_iter.next().cloned() {
+        let next = token_iter.peek().cloned();
+
+        let node = match token.clone() {
+            Token::Plus => Some(Node::new(Operator::Add)),
+            Token::Minus => {
+                if last_token_is_rightsided_value {
+                    Some(Node::new(Operator::Sub))
+                } else {
+                    Some(Node::new(Operator::Neg))
+                }
+            }
+            Token::Star => Some(Node::new(Operator::Mul)),
+            Token::Slash => Some(Node::new(Operator::Div)),
+            Token::Percent => Some(Node::new(Operator::Mod)),
+            Token::Hat => Some(Node::new(Operator::Exp)),
+
+            Token::Eq => Some(Node::new(Operator::Eq)),
+            Token::Neq => Some(Node::new(Operator::Neq)),
+            Token::Gt => Some(Node::new(Operator::Gt)),
+            Token::Lt => Some(Node::new(Operator::Lt)),
+            Token::Geq => Some(Node::new(Operator::Geq)),
+            Token::Leq => Some(Node::new(Operator::Leq)),
+            Token::And => Some(Node::new(Operator::And)),
+            Token::Or => Some(Node::new(Operator::Or)),
+            Token::Not => Some(Node::new(Operator::Not)),
+
+            Token::LBrace => {
+                root_stack.push(Node::root_node());
+                None
+            }
+            Token::RBrace => {
+                if root_stack.len() <= 1 {
+                    return Err(Error::UnmatchedRBrace);
+                } else {
+                    collapse_all_sequences(&mut root_stack)?;
+                    root_stack.pop()
+                }
+            }
+
+            Token::Assign => Some(Node::new(Operator::Assign)),
+            Token::PlusAssign => Some(Node::new(Operator::AddAssign)),
+            Token::MinusAssign => Some(Node::new(Operator::SubAssign)),
+            Token::StarAssign => Some(Node::new(Operator::MulAssign)),
+            Token::SlashAssign => Some(Node::new(Operator::DivAssign)),
+            Token::PercentAssign => Some(Node::new(Operator::ModAssign)),
+            Token::HatAssign => Some(Node::new(Operator::ExpAssign)),
+            Token::AndAssign => Some(Node::new(Operator::AndAssign)),
+            Token::OrAssign => Some(Node::new(Operator::OrAssign)),
+
+            Token::Comma => Some(Node::new(Operator::Tuple)),
+            Token::Semicolon => Some(Node::new(Operator::Chain)),
+            Token::Identifier(identifier) => {
+                let mut result = Some(Node::new(Operator::variable_identifier_read(
+                    identifier.clone(),
+                )));
+                if let Some(next) = next {
+                    if next.is_assignment() {
+                        result = Some(Node::new(Operator::variable_identifier_write(
+                            identifier.clone(),
+                        )));
+                    } else if next.is_leftsided_value() {
+                        result = Some(Node::new(Operator::function_identifier(identifier)));
+                    }
+                }
+                result
+            }
+            Token::Float(float) => Some(Node::new(Operator::value(Value::Float(float)))),
+            Token::Int(int) => Some(Node::new(Operator::value(Value::Integer(int)))),
+            Token::Boolean(boolean) => Some(Node::new(Operator::value(Value::Boolean(boolean)))),
+            Token::String(string) => Some(Node::new(Operator::value(Value::String(string)))),
+            Token::Function(string) => Some(Node::new(Operator::value(Value::Function(
+                Function::new(&string),
+            )))),
+            Token::Yield(_, _) => todo!(),
+        };
+
+        if let Some(mut node) = node {
+            // Need to pop and then repush here, because Rust 1.33.0 cannot release the mutable borrow of root_stack before the end of this complete if-statement
+            if let Some(mut root) = root_stack.pop() {
+                if node.operator().is_sequence() {
+                    // println!("Found a sequence operator");
+                    // println!("Stack before sequence operation: {:?}, {:?}", root_stack, root);
+                    // If root.operator() and node.operator() are of the same variant, ...
+                    if mem::discriminant(root.operator()) == mem::discriminant(node.operator()) {
+                        // ... we create a new root node for the next expression in the sequence
+                        root.children.push(Node::root_node());
+                        root_stack.push(root);
+                    } else if root.operator() == &Operator::RootNode {
+                        // If the current root is an actual root node, we start a new sequence
+                        node.children.push(root);
+                        node.children.push(Node::root_node());
+                        root_stack.push(Node::root_node());
+                        root_stack.push(node);
+                    } else {
+                        // Otherwise, we combine the sequences based on their precedences
+                        // TODO I'm not sure about this <, as I have no example for different sequence operators with the same precedence
+                        if root.operator().precedence() < node.operator().precedence() {
+                            // If the new sequence has a higher precedence, it is part of the last element of the current root sequence
+                            if let Some(last_root_child) = root.children.pop() {
+                                node.children.push(last_root_child);
+                                node.children.push(Node::root_node());
+                                root_stack.push(root);
+                                root_stack.push(node);
+                            } else {
+                                // Once a sequence has been pushed on top of the stack, it also gets a child
+                                unreachable!()
+                            }
+                        } else {
+                            // If the new sequence doesn't have a higher precedence, then all sequences with a higher precedence are collapsed below this one
+                            root = collapse_root_stack_to(&mut root_stack, root, &node)?;
+                            node.children.push(root);
+                            root_stack.push(node);
+                        }
+                    }
+                // println!("Stack after sequence operation: {:?}", root_stack);
+                } else if root.operator().is_sequence() {
+                    if let Some(mut last_root_child) = root.children.pop() {
+                        last_root_child.insert_back_prioritized(node, true)?;
+                        root.children.push(last_root_child);
+                        root_stack.push(root);
+                    } else {
+                        // Once a sequence has been pushed on top of the stack, it also gets a child
+                        unreachable!()
+                    }
+                } else {
+                    root.insert_back_prioritized(node, true)?;
+                    root_stack.push(root);
+                }
+            } else {
+                return Err(Error::UnmatchedRBrace);
+            }
+        }
+
+        last_token_is_rightsided_value = token.is_rightsided_value();
+    }
+
+    // In the end, all sequences are implicitly terminated
+    collapse_all_sequences(&mut root_stack)?;
+
+    if root_stack.len() > 1 {
+        Err(Error::UnmatchedLBrace)
+    } else if let Some(root) = root_stack.pop() {
+        Ok(root)
+    } else {
+        Err(Error::UnmatchedRBrace)
+    }
+}

src/value/function.rs

@@ -13,11 +13,11 @@ impl Function {
     }
 
     pub fn run(&self) -> Result<Value> {
-        todo!()
+        eval(&self.0)
     }
 
     pub fn run_with_context(&self, context: &mut VariableMap) -> Result<Value> {
-        todo!()
+        eval_with_context(&self.0, context)
     }
 }
 

src/value/mod.rs

@@ -10,7 +10,7 @@ use serde::{
     ser::SerializeTuple,
     Deserialize, Serialize, Serializer,
 };
-use tree_sitter::Node;
+use tree_sitter::{Node, TreeCursor};
 
 use std::{
     cmp::Ordering,
@@ -66,12 +66,6 @@ impl Value {
 
                 Ok(Value::Integer(raw))
             }
-            "string" => {
-                let without_quotes = &value_snippet[1..value_snippet.len() - 1];
-
-                Ok(Value::String(without_quotes.to_string()))
-            }
-            "empty" => Ok(Value::Empty),
             _ => Err(Error::UnexpectedSourceNode {
                 expected: "raw value",
                 actual: child.kind(),
@@ -258,7 +252,7 @@ impl Add for Value {
 
                 Ok(Value::String(concatenated))
             }
-            (Value::String(_), other) | (other, Value::String(_)) => {
+            (Value::String(string), other) | (other, Value::String(string)) => {
                 Err(Error::ExpectedString { actual: other })
             }
             (Value::Float(left), Value::Float(right)) => {