language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-02 16:21:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge branch 'trunk' into list-push

Browse source
This commit is contained in:
Richard Feldman 2020-06-23 21:19:08 -04:00 • committed by GitHub
commit 93a2cd994d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 602 additions and 490 deletions
Download patch file Download diff file Expand all files Collapse all files

879
compiler/builtins/src/unique.rs
View file

File diff suppressed because it is too large Load diff

4
compiler/load/tests/test_uniq_load.rs
View file

@ -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))))) ])",
"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)))))",
"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 Shared a)))), Attr Shared Int, Attr Shared Int -> Attr b (List (Attr Shared (Num (Attr Shared a)))))",
},
);
});

1
compiler/module/src/symbol.rs
View file

@ -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

208
compiler/solve/tests/test_uniq_solve.rs
View file

@ -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"#),
"Attr * (Attr (* | a | b) (List (Attr a c)), Attr (a | b) c -> Attr * (List (Attr a c)))"
"List.push",
"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 * (List (Attr (a | b) c)) -> Attr (* | a | b) (List (Attr a c)))",
"Attr * (Attr (* | a) (List (Attr a b)) -> Attr * (List (Attr a b)))",
);
}
@ -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!(
r#"
\a, b -> a == b
"#
),
"Attr * (a, a -> Attr * Bool)",
"\\a, b -> a == b",
"Attr * (Attr * a, Attr * 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 * *)))",
);
}
}