feat: union types

src/modules/types.rs

@@ -1,26 +1,59 @@
 use std::fmt::Display;
 
 use heraclitus_compiler::prelude::*;
+use itertools::Itertools;
 use crate::utils::ParserMetadata;
 
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, Eq, Default)]
 pub enum Type {
     #[default] Null,
     Text,
     Bool,
     Num,
+    Union(Vec<Type>),
     Array(Box<Type>),
     Failable(Box<Type>),
     Generic
 }
 
+impl Type {
+    fn eq_union_normal(one: &[Type], other: &Type) -> bool {
+        one.iter().any(|x| (*x).to_string() == other.to_string())
+    }
+
+    fn eq_unions(one: &[Type], other: &[Type]) -> bool {
+        one.iter().any(|x| {
+            Self::eq_union_normal(other, x)
+        })
+    }
+}
+
+impl PartialEq for Type {
+    fn eq(&self, other: &Self) -> bool {
+        if let Type::Union(union) = self {
+            if let Type::Union(other) = other {
+                return Type::eq_unions(union, other);
+            } else {
+                return Type::eq_union_normal(union, other);
+            }
+        }
+
+        if let Type::Union(other) = other {
+            Type::eq_union_normal(other, self)
+        } else {
+            self.to_string() == other.to_string()
+        }
+    }
+}
+
 impl Display for Type {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Type::Text => write!(f, "Text"),
             Type::Bool => write!(f, "Bool"),
             Type::Num => write!(f, "Num"),
             Type::Null => write!(f, "Null"),
+            Type::Union(types) => write!(f, "{}", types.iter().map(|x| format!("{x}")).join(" | ")),
             Type::Array(t) => write!(f, "[{}]", t),
             Type::Failable(t) => write!(f, "{}?", t),
             Type::Generic => write!(f, "Generic")
@@ -39,10 +72,8 @@ pub fn parse_type(meta: &mut ParserMetadata) -> Result<Type, Failure> {
         .map_err(|_| Failure::Loud(Message::new_err_at_token(meta, tok).message("Expected a data type")))
 }
 
-// Tries to parse the type - if it fails, it fails quietly
-pub fn try_parse_type(meta: &mut ParserMetadata) -> Result<Type, Failure> {
-    let tok = meta.get_current_token();
-    let res = match tok.clone() {
+fn parse_type_tok(meta: &mut ParserMetadata, tok: Option<Token>) -> Result<Type, Failure> {
+    match tok.clone() {
         Some(matched_token) => {
             match matched_token.word.as_ref() {
                 "Text" => {
@@ -99,10 +130,35 @@ pub fn try_parse_type(meta: &mut ParserMetadata) -> Result<Type, Failure> {
         None => {
             Err(Failure::Quiet(PositionInfo::at_eof(meta)))
         }
-    };
+    }
+}
 
+fn parse_one_type(meta: &mut ParserMetadata, tok: Option<Token>) -> Result<Type, Failure> {
+    let res = parse_type_tok(meta, tok)?;
     if token(meta, "?").is_ok() {
-        return res.map(|t| Type::Failable(Box::new(t)))
+        return Ok(Type::Failable(Box::new(res)))
+    }
+    Ok(res)
+}
+
+// Tries to parse the type - if it fails, it fails quietly
+pub fn try_parse_type(meta: &mut ParserMetadata) -> Result<Type, Failure> {
+    let tok = meta.get_current_token();
+    let res = parse_one_type(meta, tok);
+
+    if token(meta, "|").is_ok() {
+        // is union type
+        let mut unioned = vec![ res? ];
+        loop {
+            match parse_one_type(meta, meta.get_current_token()) {
+                Err(err) => return Err(err),
+                Ok(t) => unioned.push(t)
+            };
+            if token(meta, "|").is_err() {
+                break;
+            }
+        }
+        return Ok(Type::Union(unioned))
     }
 
     res

src/tests/errors.rs

@@ -1,5 +1,7 @@
 use super::test_amber;
 
+mod unions;
+
 #[test]
 #[should_panic(expected = "ERROR: Return type does not match function return type")]
 fn function_with_wrong_typed_return() {

src/tests/errors/unions.rs

@@ -0,0 +1,32 @@
+use crate::tests::test_amber;
+
+#[test]
+#[should_panic(expected = "ERROR: 1st argument 'param' of function 'abc' expects type 'Text | Null', but 'Num' was given")]
+fn invalid_union_type_eq_normal_type() {
+    let code = r#"
+        fun abc(param: Text | Null) {}
+        abc("")
+        abc(123)
+    "#;
+    test_amber(code, "");
+}
+
+#[test]
+#[should_panic(expected = "ERROR: 1st argument 'param' of function 'abc' expects type 'Text | Null', but 'Num | [Text]' was given")]
+fn invalid_two_unions() {
+    let code = r#"
+        fun abc(param: Text | Null) {}
+        abc(123 as Num | [Text])
+    "#;
+    test_amber(code, "");
+}
+
+#[test]
+#[should_panic(expected = "ERROR: 1st argument 'param' of function 'abc' expects type 'Text | Num | Text? | Num? | [Null]', but 'Null' was given")]
+fn big_union() {
+    let code = r#"
+        fun abc(param: Text | Num | Text? | Num? | [Null]) {}
+        abc(null)
+    "#;
+    test_amber(code, "");
+}

src/tests/validity/function_with_union_types.ab

@@ -0,0 +1,10 @@
+// Output
+// abc
+// 123
+
+fun check(thing: Text | Num): Null {
+    echo thing
+}
+
+check("abc")
+check(123)

src/tests/validity/union_types.ab

@@ -0,0 +1,7 @@
+// Output
+// 123
+
+let thingy = "abc" as Text | Num;
+thingy = 123;
+
+echo thingy;

src/tests/validity/union_types_if.ab

@@ -0,0 +1,19 @@
+// Output
+// is text
+// abc
+// is num
+// 123
+
+fun check(thing: Text | Num): Null {
+    if thing is Text {
+        echo "is text"
+        echo thing
+    }
+    if thing is Num {
+        echo "is num"
+        echo thing
+    }
+}
+
+check("abc")
+check(123)