Merge branch 'trunk' into list-push

compiler/load/tests/test_uniq_load.rs

@@ -242,8 +242,8 @@ mod test_uniq_load {
                 loaded_module,
                 hashmap! {
                     "swap" => "Attr * (Attr Shared Int, Attr Shared Int, Attr * (List (Attr Shared a)) -> Attr * (List (Attr Shared a)))",
-                    "partition" => "Attr * (Attr Shared Int, Attr Shared Int, Attr b (List (Attr Shared (Num (Attr c a)))) -> Attr * [ Pair (Attr * Int) (Attr b (List (Attr Shared (Num (Attr c a))))) ])",
+                    "partition" => "Attr * (Attr Shared Int, Attr Shared Int, Attr b (List (Attr Shared (Num (Attr Shared a)))) -> Attr * [ Pair (Attr Shared Int) (Attr b (List (Attr Shared (Num (Attr Shared a))))) ])",
-                    "quicksort" => "Attr Shared (Attr b (List (Attr Shared (Num (Attr c a)))), Attr Shared Int, Attr Shared Int -> Attr b (List (Attr Shared (Num (Attr c a)))))",
+                    "quicksort" => "Attr Shared (Attr b (List (Attr Shared (Num (Attr Shared a)))), Attr Shared Int, Attr Shared Int -> Attr b (List (Attr Shared (Num (Attr Shared a)))))",
                 },
             );
         });

compiler/module/src/symbol.rs

@@ -672,6 +672,7 @@ define_builtins! {
         0 STR_STR: "Str" imported // the Str.Str type alias
         1 STR_AT_STR: "@Str" // the Str.@Str private tag
         2 STR_ISEMPTY: "isEmpty"
+        3 STR_APPEND: "append"
     }
     6 LIST: "List" => {
         0 LIST_LIST: "List" imported // the List.List type alias

compiler/solve/tests/test_uniq_solve.rs

@@ -1475,7 +1475,7 @@ mod test_uniq_solve {
                 quicksort
                    "#
             ),
-            "Attr Shared (Attr b (List (Attr Shared (Num (Attr c a)))), Attr Shared Int, Attr Shared Int -> Attr b (List (Attr Shared (Num (Attr c a)))))"
+            "Attr Shared (Attr b (List (Attr Shared (Num (Attr Shared a)))), Attr Shared Int, Attr Shared Int -> Attr b (List (Attr Shared (Num (Attr Shared a)))))"
         );
         })
     }
@@ -1885,12 +1885,12 @@ mod test_uniq_solve {
                     4 + 4
                 "#
             ),
-            "Attr * (Num (Attr * *))",
+            "Attr a (Num (Attr a *))",
         );
     }
 
     #[test]
-    fn list_get() {
+    fn list_get_at() {
         infer_eq(
             indoc!(
                 r#"
@@ -2004,7 +2004,7 @@ mod test_uniq_solve {
                                 list
                "#
             ),
-            "Attr * (Attr a (List (Attr Shared (Num (Attr b c)))) -> Attr a (List (Attr Shared (Num (Attr b c)))))",
+            "Attr * (Attr a (List (Attr Shared (Num (Attr Shared b)))) -> Attr a (List (Attr Shared (Num (Attr Shared b)))))",
         );
     }
 
@@ -2024,19 +2024,6 @@ mod test_uniq_solve {
         );
     }
 
-    #[test]
-    fn list_set() {
-        infer_eq(indoc!(r#"List.set"#), "Attr * (Attr (* | a | b) (List (Attr a c)), Attr * Int, Attr (a | b) c -> Attr * (List (Attr a c)))");
-    }
-
-    #[test]
-    fn list_map() {
-        infer_eq(
-            indoc!(r#"List.map"#),
-            "Attr * (Attr * (List a), Attr Shared (a -> b) -> Attr * (List b))",
-        );
-    }
-
     #[test]
     fn list_map_identity() {
         infer_eq(
@@ -2045,14 +2032,6 @@ mod test_uniq_solve {
         );
     }
 
-    #[test]
-    fn list_foldr() {
-        infer_eq(
-            indoc!(r#"List.foldr"#),
-            "Attr * (Attr * (List a), Attr Shared (a, b -> b), b -> b)",
-        );
-    }
-
     #[test]
     fn list_foldr_sum() {
         infer_eq(
@@ -2063,15 +2042,72 @@ mod test_uniq_solve {
                     sum
                 "#
             ),
-            "Attr * (Attr * (List (Attr * (Num (Attr a b)))) -> Attr * (Num (Attr a b)))",
+            "Attr * (Attr (* | a) (List (Attr a (Num (Attr a b)))) -> Attr c (Num (Attr c b)))",
+        );
+    }
+
+    #[test]
+    fn num_add() {
+        infer_eq(
+            "Num.add",
+            "Attr * (Attr a (Num (Attr a b)), Attr c (Num (Attr c b)) -> Attr d (Num (Attr d b)))",
+        );
+    }
+
+    #[test]
+    fn list_isempty() {
+        infer_eq("List.isEmpty", "Attr * (Attr * (List *) -> Attr * Bool)");
+    }
+
+    #[test]
+    fn list_len() {
+        infer_eq("List.len", "Attr * (Attr * (List *) -> Attr * Int)");
+    }
+
+    #[test]
+    fn list_get() {
+        infer_eq("List.get", "Attr * (Attr (* | a) (List (Attr a b)), Attr * Int -> Attr * (Result (Attr a b) (Attr * [ OutOfBounds ]*)))");
+    }
+
+    #[test]
+    fn list_set() {
+        infer_eq("List.set", "Attr * (Attr (* | a | b) (List (Attr a c)), Attr * Int, Attr (a | b) c -> Attr * (List (Attr a c)))");
+    }
+
+    #[test]
+    fn list_single() {
+        infer_eq("List.single", "Attr * (a -> Attr * (List a))");
+    }
+
+    #[test]
+    fn list_repeat() {
+        infer_eq(
+            "List.repeat",
+            "Attr * (Attr * Int, Attr Shared a -> Attr * (List (Attr Shared a)))",
         );
     }
 
     #[test]
     fn list_push() {
         infer_eq(
-            indoc!(r#"List.push"#),
+            "List.push",
-            "Attr * (Attr (* | a | b) (List (Attr a c)), Attr (a | b) c -> Attr * (List (Attr a c)))"
+            "Attr * (Attr * (List a), a -> Attr * (List a))",
+        );
+    }
+
+    #[test]
+    fn list_map() {
+        infer_eq(
+            "List.map",
+            "Attr * (Attr * (List a), Attr Shared (a -> b) -> Attr * (List b))",
+        );
+    }
+
+    #[test]
+    fn list_foldr() {
+        infer_eq(
+            "List.foldr",
+            "Attr * (Attr (* | a) (List (Attr a b)), Attr Shared (Attr a b, c -> c), c -> c)",
         );
     }
 
@@ -2085,7 +2121,7 @@ mod test_uniq_solve {
                     singleton
                 "#
             ),
-            "Attr * (Attr (* | a) b -> Attr * (List (Attr a b)))",
+            "Attr * (a -> Attr * (List a))",
         );
     }
 
@@ -2099,8 +2135,7 @@ mod test_uniq_solve {
                     reverse
                 "#
             ),
-            // "Attr * (Attr * (List (Attr (a | b) c)) -> Attr (* | a | b) (List (Attr b c)))",
+            "Attr * (Attr (* | a) (List (Attr a b)) -> Attr * (List (Attr a b)))",
-            "Attr * (Attr * (List (Attr (a | b) c)) -> Attr (* | a | b) (List (Attr a c)))",
         );
     }
 
@@ -2116,6 +2151,97 @@ mod test_uniq_solve {
         );
     }
 
+    #[test]
+    fn set_empty() {
+        infer_eq("Set.empty", "Attr * (Set *)");
+    }
+
+    #[test]
+    fn set_singelton() {
+        infer_eq("Set.singleton", "Attr * (a -> Attr * (Set a))");
+    }
+
+    #[test]
+    fn set_union() {
+        infer_eq(
+            "Set.union",
+            "Attr * (Attr * (Set (Attr * a)), Attr * (Set (Attr * a)) -> Attr * (Set (Attr * a)))",
+        );
+    }
+
+    #[test]
+    fn set_diff() {
+        infer_eq(
+            "Set.diff",
+            "Attr * (Attr * (Set (Attr * a)), Attr * (Set (Attr * a)) -> Attr * (Set (Attr * a)))",
+        );
+    }
+
+    #[test]
+    fn set_foldl() {
+        infer_eq(
+            "Set.foldl",
+            "Attr * (Attr (* | a) (Set (Attr a b)), Attr Shared (Attr a b, c -> c), c -> c)",
+        );
+    }
+
+    #[test]
+    fn set_insert() {
+        infer_eq("Set.insert", "Attr * (Attr * (Set a), a -> Attr * (Set a))");
+    }
+
+    #[test]
+    fn set_remove() {
+        infer_eq(
+            "Set.remove",
+            "Attr * (Attr * (Set (Attr a b)), Attr * b -> Attr * (Set (Attr a b)))",
+        );
+    }
+
+    #[test]
+    fn map_empty() {
+        infer_eq("Map.empty", "Attr * (Map * *)");
+    }
+
+    #[test]
+    fn map_singelton() {
+        infer_eq("Map.singleton", "Attr * (a, b -> Attr * (Map a b))");
+    }
+
+    #[test]
+    fn map_get() {
+        infer_eq("Map.get", "Attr * (Attr (* | a) (Map (Attr * b) (Attr a c)), Attr * b -> Attr * (Result (Attr a c) (Attr * [ KeyNotFound ]*)))");
+    }
+
+    #[test]
+    fn map_insert() {
+        infer_eq(
+            "Map.insert",
+            "Attr * (Attr * (Map a b), a, b -> Attr * (Map a b))",
+        );
+    }
+
+    #[test]
+    fn str_is_empty() {
+        infer_eq("Str.isEmpty", "Attr * (Attr * Str -> Attr * Bool)");
+    }
+
+    #[test]
+    fn str_append() {
+        infer_eq(
+            "Str.append",
+            "Attr * (Attr * Str, Attr * Str -> Attr * Str)",
+        );
+    }
+
+    #[test]
+    fn result_map() {
+        infer_eq(
+            "Result.map",
+            "Attr * (Attr * (Result a b), Attr * (a -> c) -> Attr * (Result c b))",
+        );
+    }
+
     #[test]
     fn use_correct_ext_var() {
         infer_eq(
@@ -2367,14 +2493,18 @@ mod test_uniq_solve {
     }
 
     #[test]
-    fn equals() {
+    fn bool_eq() {
         infer_eq(
-            indoc!(
+            "\\a, b -> a == b",
-                r#"
+            "Attr * (Attr * a, Attr * a -> Attr * Bool)",
-                \a, b -> a == b
+        );
-                "#
+    }
-            ),
+
-            "Attr * (a, a -> Attr * Bool)",
+    #[test]
+    fn bool_neq() {
+        infer_eq(
+            "\\a, b -> a != b",
+            "Attr * (Attr * a, Attr * a -> Attr * Bool)",
         );
     }
 
@@ -2409,7 +2539,7 @@ mod test_uniq_solve {
                         _ -> 3
                 "#
             ),
-            "Attr * (Attr Shared (Num (Attr * *)) -> Attr * (Num (Attr * *)))",
+            "Attr * (Attr Shared (Num (Attr Shared *)) -> Attr * (Num (Attr * *)))",
         );
     }
 }