Add boolean type.

Cargo.toml

@@ -38,4 +38,4 @@ opt-level = 3
 
 [lints]
 clippy.useless_format = "allow"
-rust.missing_docs = "warn"
+rust.missing_docs = "warn"

src/builtin_parser/lexer.rs

@@ -54,6 +54,11 @@ pub enum Token {
     #[token(",")]
     Comma,
 
+    #[token("true")]
+    True,
+    #[token("false")]
+    False,
+
     #[regex(r#""(\\[\\"]|[^"])*""#)]
     String,
 

src/builtin_parser/parser.rs

@@ -64,6 +64,7 @@ pub enum Expression {
         arguments: Vec<Spanned<Expression>>,
     },
     Object(HashMap<String, Spanned<Expression>>),
+    Boolean(bool),
 }
 
 #[derive(Debug, Clone)]
@@ -293,6 +294,8 @@ fn parse_primary(
         Some(Ok(Token::Number)) => {
             Ok(tokens.wrap_span(Expression::Number(tokens.slice().parse().unwrap())))
         }
+        Some(Ok(Token::True)) => Ok(tokens.wrap_span(Expression::Boolean(true))),
+        Some(Ok(Token::False)) => Ok(tokens.wrap_span(Expression::Boolean(false))),
         Some(Ok(token)) => Err(ParseError::UnexpectedToken(tokens.wrap_span(token))),
         Some(Err(FailedToLexCharacter)) => Err(ParseError::FailedToLexCharacter(tokens.span())),
         None => unreachable!("oh fuck what have i done to cause this to happen"),

src/builtin_parser/runner.rs

@@ -294,6 +294,7 @@ fn eval_expression(
             }
         }
         Expression::None => Ok(Value::None),
+        Expression::Boolean(bool) => Ok(Value::Boolean(bool)),
         Expression::Function { name, arguments } => {
             environment.function_scope(&name, move |environment, function| {
                 (function.body)(
@@ -463,7 +464,8 @@ fn set_resource(
                     let mut dyn_struct = DynamicStruct::default();
                     for (key, value) in map.into_iter() {
                         match Rc::try_unwrap(value).unwrap().into_inner() {
-                            Value::None => {}
+                            Value::None => dyn_struct.insert(&key, ()),
+                            Value::Boolean(boolean) => dyn_struct.insert(&key, boolean),
                             Value::Number(number) => dyn_struct.insert(&key, number),
                             Value::String(string) => dyn_struct.insert(&key, string.clone()),
                             Value::Reference(..) => todo!("todo reference"),

src/builtin_parser/runner/value.rs

@@ -17,6 +17,8 @@ pub enum Value {
     None,
     /// A number, for simplicity only f64s are used. (However this will probably change in the future)
     Number(f64),
+    /// `true` or `false`. Thats it...
+    Boolean(bool),
     /// A string... there isn't much to say about this one.
     String(String),
     /// A reference.
@@ -51,6 +53,7 @@ impl Value {
         match self {
             Value::None => Ok(format!("()")),
             Value::Number(number) => Ok(format!("{number}")),
+            Value::Boolean(bool) => Ok(format!("{bool}")),
             Value::String(string) => Ok(format!("\"{string}\"")),
             Value::Reference(reference) => {
                 if let Some(rc) = reference.upgrade() {