feat: union types

src/modules/types.rs

@@ -1,26 +1,108 @@
 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 {
+        let bigger;
+        let smaller = if one.len() < other.len() { bigger = other; one } else { bigger = one; other };
+
+        smaller.iter().all(|x| {
+            Self::eq_union_normal(bigger, x)
+        })
+    }
+
+    /**
+        Hash is calculated in a hex number with 8 digits. Each digit has its own meaning.
+
+        Last two digits are reserved for "singular" types, like text and/or bool.
+
+        # Important
+        This hash is not supposed to be readed.  
+        It is generated in a way that it can't collide, but it is not supposed to be used for representing a type.
+
+        ```
+        0x00 00 00 00
+          ^^ ^^ ^^ ^^ -- singular type indicator
+                || -- -- number of nested arrays, such as [Num] will be 1, and [[[Num]]] will be 3.
+             || --    -- modifier
+          || --       -- reserved for future use
+        ```
+
+        ## Modifiers
+        These modifiers are valid:
+
+        | code | desc          |
+        | ---- | ------------- |
+        | `00` | no modifier   |
+        | `01` | failable type |
+     */
+    fn type_hash(&self) -> u32 {
+        match self {
+            Type::Null    => 0x00000001,
+            Type::Text    => 0x00000002,
+            Type::Bool    => 0x00000003,
+            Type::Num     => 0x00000004,
+            Type::Generic => 0x00000005,
+
+            Type::Array(t) => t.type_hash() + 0x00000100,
+
+            Type::Failable(t) => {
+                if let Type::Failable(_) = **t {
+                    panic!("Failable types can't be nested!");
+                }
+                t.type_hash() + 0x00010000
+            },
+
+            Type::Union(_) => unreachable!("Type hash is not available for union types! Use the PartialEq trait instead"),
+        }
+    }
+}
+
+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.type_hash() == other.type_hash()
+        }
+    }
+}
+
 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 +121,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 +179,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/mod.rs

@@ -9,6 +9,7 @@ pub mod cli;
 pub mod errors;
 pub mod extra;
 pub mod formatter;
+pub mod types;
 mod stdlib;
 mod validity;
 

src/tests/types/eq.rs

@@ -0,0 +1,34 @@
+use crate::modules::types::Type;
+
+#[test]
+fn normal_types_eq() {
+    let types = vec![Type::Null, Type::Text, Type::Bool, Type::Num, Type::Generic];
+    for typ in types {
+        assert_eq!(typ, typ, "{typ} and {typ} must be equal!");
+    }
+}
+
+#[test]
+fn two_different_normal_types() {
+    assert_ne!(Type::Null, Type::Bool);
+}
+
+#[test]
+fn normal_and_failable_type() {
+    assert_ne!(Type::Failable(Box::new(Type::Text)), Type::Text, "Text? and Text must not be equal!")
+}
+
+#[test]
+fn array_and_normal_type() {
+    assert_ne!(Type::Array(Box::new(Type::Bool)), Type::Bool);
+}
+
+#[test]
+fn array_and_array_of_failables() {
+    assert_ne!(Type::Array(Box::new(Type::Bool)), Type::Array(Box::new(Type::Failable(Box::new(Type::Bool)))));
+}
+
+#[test]
+fn nested_array_normal_array_with_failable() {
+    assert_ne!(Type::Array(Box::new(Type::Array(Box::new(Type::Bool)))), Type::Failable(Box::new(Type::Bool)));
+}

src/tests/types/mod.rs

@@ -0,0 +1,2 @@
+pub mod union;
+pub mod eq;

src/tests/types/union.rs

@@ -0,0 +1,73 @@
+use crate::modules::types::Type;
+
+#[test]
+fn partially_overlapping_types() {
+    let one = Type::Union(vec![Type::Text, Type::Num]);
+    let two = Type::Union(vec![Type::Num, Type::Null]);
+
+    assert_ne!(one, two, "Text | Num must not be equal to Num | Null!")
+}
+
+#[test]
+fn overlapping_types() {
+    let one = Type::Union(vec![Type::Text, Type::Num]);
+    let two = Type::Union(vec![Type::Text, Type::Num, Type::Null]);
+
+    assert_eq!(one, two, "Text | Num must be equal to Text | Num | Null!")
+}
+
+#[test]
+fn same_union() {
+    let one = Type::Union(vec![Type::Text, Type::Num]);
+    let two = Type::Union(vec![Type::Text, Type::Num]);
+
+    assert_eq!(one, two, "Text | Num must be equal to Text | Num!")
+}
+
+#[test]
+fn empty_union() {
+    let one = Type::Union(vec![]);
+    let two = Type::Union(vec![]);
+
+    assert_eq!(one, two, "If one of unions is empty, it must always be equal to another")
+}
+
+#[test]
+fn empty_and_normal_union() {
+    let one = Type::Union(vec![Type::Text, Type::Num]);
+    let two = Type::Union(vec![]);
+
+    assert_eq!(one, two, "If one of unions is empty, it must always be equal to another")
+}
+
+#[test]
+fn empty_union_and_normal_type() {
+    let one = Type::Union(vec![]);
+    let two = Type::Text;
+
+    assert_ne!(one, two, "An empty union and one type are not equal")
+}
+
+#[test]
+fn big_union() {
+    let one = Type::Union(vec![Type::Text, Type::Text, Type::Text, Type::Text, Type::Text, Type::Text, Type::Text, Type::Num]);
+    let two = Type::Union(vec![Type::Text, Type::Num]);
+
+    assert_eq!(one, two, "Text | Text | ... | Text | Num and Text | Num must be equal!")
+}
+
+#[test]
+fn normal_and_union() {
+    let one = Type::Text;
+    let two = Type::Union(vec![Type::Text, Type::Null]);
+
+    assert_eq!(one, two, "Text and Text | Null must be equal!");
+}
+
+#[test]
+fn normal_not_in_union() {
+    let one = Type::Text;
+    let two = Type::Union(vec![Type::Num, Type::Null]);
+
+    assert_ne!(one, two, "Text and Num | Null must not be equal!");
+}

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)