language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-26 13:29:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

More progress

Browse source
This commit is contained in:
Sam Mohr 2025-01-05 05:16:47 -08:00
parent b56fbd38e1
commit 0edbf16d55
No known key found for this signature in database
GPG key ID: EA41D161A3C1BC99
79 changed files with 1351 additions and 1419 deletions
Download patch file Download diff file Expand all files Collapse all files

167
crates/compiler/builtins/roc/Dict.roc
View file

@ -116,14 +116,17 @@ is_eq = \xs, ys ->
if len(xs) != len(ys) then if len(xs) != len(ys) then
Bool.false Bool.false
else else
walk_until(xs, Bool.true, (\_, k, x_val -> walk_until(
when get(ys, k) is xs,
Ok y_val if y_val == x_val -> Bool.true,
Continue Bool.true \_, k, x_val ->
when get(ys, k) is
Ok(y_val) if y_val == x_val ->
Continue(Bool.true)
_ -> _ ->
Break Bool.false Break(Bool.false),
)) )
hash_dict : hasher, Dict k v -> hasher where v implements Hash, hasher implements Hasher hash_dict : hasher, Dict k v -> hasher where v implements Hash, hasher implements Hasher
hash_dict = \hasher, dict -> Hash.hash_unordered(hasher, to_list(dict), List.walk) hash_dict = \hasher, dict -> Hash.hash_unordered(hasher, to_list(dict), List.walk)
@ -157,7 +160,7 @@ with_capacity = \requested ->
## Enlarge the dictionary for at least capacity additional elements ## Enlarge the dictionary for at least capacity additional elements
reserve : Dict k v, U64 -> Dict k v reserve : Dict k v, U64 -> Dict k v
reserve = \@Dict { buckets, data, max_bucket_capacity: original_max_bucket_capacity, max_load_factor, shifts }, requested -> reserve = \@Dict({ buckets, data, max_bucket_capacity: original_max_bucket_capacity, max_load_factor, shifts }), requested ->
current_size = List.len(data) current_size = List.len(data)
requested_size = Num.add_wrap(current_size, requested) requested_size = Num.add_wrap(current_size, requested)
size = Num.min(requested_size, max_size) size = Num.min(requested_size, max_size)
@ -180,7 +183,7 @@ reserve = \@Dict { buckets, data, max_bucket_capacity: original_max_bucket_capac
## This function will require regenerating the metadata if the size changes. ## This function will require regenerating the metadata if the size changes.
## There will still be some overhead due to dictionary metadata always being a power of 2. ## There will still be some overhead due to dictionary metadata always being a power of 2.
release_excess_capacity : Dict k v -> Dict k v release_excess_capacity : Dict k v -> Dict k v
release_excess_capacity = \@Dict { buckets, data, max_bucket_capacity: original_max_bucket_capacity, max_load_factor, shifts } -> release_excess_capacity = \@Dict({ buckets, data, max_bucket_capacity: original_max_bucket_capacity, max_load_factor, shifts }) ->
size = List.len(data) size = List.len(data)
# NOTE: If we want, we technically could increase the load factor here to potentially minimize size more. # NOTE: If we want, we technically could increase the load factor here to potentially minimize size more.
@ -237,7 +240,7 @@ single = \k, v ->
## with the same capacity of the list and walk it calling [Dict.insert] ## with the same capacity of the list and walk it calling [Dict.insert]
from_list : List (k, v) -> Dict k v from_list : List (k, v) -> Dict k v
from_list = \data -> from_list = \data ->
List.walk(data, empty({}), (\dict, (k, v) -> insert(dict, k, v))) List.walk(data, empty({}), \dict, (k, v) -> insert(dict, k, v))
## Returns the number of values in the dictionary. ## Returns the number of values in the dictionary.
## ```roc ## ```roc
@ -250,7 +253,7 @@ from_list = \data ->
## |> Bool.is_eq(3) ## |> Bool.is_eq(3)
## ``` ## ```
len : Dict * * -> U64 len : Dict * * -> U64
len = \@Dict { data } -> len = \@Dict({ data }) ->
List.len(data) List.len(data)
## Check if the dictionary is empty. ## Check if the dictionary is empty.
@ -278,7 +281,7 @@ is_empty = \@Dict({ data }) ->
clear : Dict k v -> Dict k v clear : Dict k v -> Dict k v
clear = \@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }) -> clear = \@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }) ->
@Dict({ @Dict({
buckets: List.map(buckets, (\_ -> empty_bucket)), buckets: List.map(buckets, \_ -> empty_bucket),
# use take_first to keep around the capacity # use take_first to keep around the capacity
data: List.take_first(data, 0), data: List.take_first(data, 0),
max_bucket_capacity, max_bucket_capacity,
@ -293,9 +296,12 @@ map : Dict k a, (k, a -> b) -> Dict k b
map = \dict, transform -> map = \dict, transform ->
init = with_capacity(capacity(dict)) init = with_capacity(capacity(dict))
walk(dict, init, (\answer, k, v -> walk(
insert(answer, k, transform(k, v)) dict,
)) init,
\answer, k, v ->
insert(answer, k, transform(k, v)),
)
## Like [Dict.map], except the transformation function wraps the return value ## Like [Dict.map], except the transformation function wraps the return value
## in a dictionary. At the end, all the dictionaries get joined together ## in a dictionary. At the end, all the dictionaries get joined together
@ -306,9 +312,12 @@ join_map : Dict a b, (a, b -> Dict x y) -> Dict x y
join_map = \dict, transform -> join_map = \dict, transform ->
init = with_capacity(capacity(dict)) # Might be a pessimization init = with_capacity(capacity(dict)) # Might be a pessimization
walk(dict, init, (\answer, k, v -> walk(
insert_all(answer, transform(k, v)) dict,
)) init,
\answer, k, v ->
insert_all(answer, transform(k, v)),
)
## Iterate through the keys and values in the dictionary and call the provided ## Iterate through the keys and values in the dictionary and call the provided
## function with signature `state, k, v -> state` for each value, with an ## function with signature `state, k, v -> state` for each value, with an
@ -323,7 +332,7 @@ join_map = \dict, transform ->
## ``` ## ```
walk : Dict k v, state, (state, k, v -> state) -> state walk : Dict k v, state, (state, k, v -> state) -> state
walk = \@Dict({ data }), initial_state, transform -> walk = \@Dict({ data }), initial_state, transform ->
List.walk(data, initial_state, (\state, (k, v) -> transform(state, k, v))) List.walk(data, initial_state, \state, (k, v) -> transform(state, k, v))
## Same as [Dict.walk], except you can stop walking early. ## Same as [Dict.walk], except you can stop walking early.
## ##
@ -355,7 +364,7 @@ walk = \@Dict({ data }), initial_state, transform ->
## ``` ## ```
walk_until : Dict k v, state, (state, k, v -> [Continue state, Break state]) -> state walk_until : Dict k v, state, (state, k, v -> [Continue state, Break state]) -> state
walk_until = \@Dict({ data }), initial_state, transform -> walk_until = \@Dict({ data }), initial_state, transform ->
List.walk_until(data, initial_state, (\state, (k, v) -> transform(state, k, v))) List.walk_until(data, initial_state, \state, (k, v) -> transform(state, k, v))
## Run the given function on each key-value pair of a dictionary, and return ## Run the given function on each key-value pair of a dictionary, and return
## a dictionary with just the pairs for which the function returned `Bool.true`. ## a dictionary with just the pairs for which the function returned `Bool.true`.
@ -396,7 +405,7 @@ keep_if_help = \@Dict(dict), predicate, index, length ->
## ``` ## ```
drop_if : Dict k v, ((k, v) -> Bool) -> Dict k v drop_if : Dict k v, ((k, v) -> Bool) -> Dict k v
drop_if = \dict, predicate -> drop_if = \dict, predicate ->
Dict.keep_if(dict, (\e -> Bool.not(predicate(e)))) Dict.keep_if(dict, \e -> Bool.not(predicate(e)))
## Get the value for a given key. If there is a value for the specified key it ## Get the value for a given key. If there is a value for the specified key it
## will return [Ok value], otherwise return [Err KeyNotFound]. ## will return [Ok value], otherwise return [Err KeyNotFound].
@ -527,7 +536,7 @@ update : Dict k v, k, (Result v [Missing] -> Result v [Missing]) -> Dict k v
update = \@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }), key, alter -> update = \@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }), key, alter ->
{ bucket_index, result } = find(@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }), key) { bucket_index, result } = find(@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }), key)
when result is when result is
Ok value -> Ok(value) ->
when alter(Ok(value)) is when alter(Ok(value)) is
Ok(new_value) -> Ok(new_value) ->
bucket = list_get_unsafe(buckets, bucket_index) bucket = list_get_unsafe(buckets, bucket_index)
@ -537,7 +546,7 @@ update = \@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts })
Err(Missing) -> Err(Missing) ->
remove_bucket(@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }), bucket_index) remove_bucket(@Dict({ buckets, data, max_bucket_capacity, max_load_factor, shifts }), bucket_index)
Err KeyNotFound -> Err(KeyNotFound) ->
when alter(Err(Missing)) is when alter(Err(Missing)) is
Ok(new_value) -> Ok(new_value) ->
if List.len(data) >= max_bucket_capacity then if List.len(data) >= max_bucket_capacity then
@ -601,7 +610,7 @@ to_list = \@Dict({ data }) ->
## ``` ## ```
keys : Dict k v -> List k keys : Dict k v -> List k
keys = \@Dict({ data }) -> keys = \@Dict({ data }) ->
List.map(data, (\(k, _) -> k)) List.map(data, \(k, _) -> k)
## Returns the values of a dictionary as a [List]. ## Returns the values of a dictionary as a [List].
## This requires allocating a temporary [List], prefer using [Dict.to_list] or [Dict.walk] instead. ## This requires allocating a temporary [List], prefer using [Dict.to_list] or [Dict.walk] instead.
@ -616,7 +625,7 @@ keys = \@Dict({ data }) ->
## ``` ## ```
values : Dict k v -> List v values : Dict k v -> List v
values = \@Dict({ data }) -> values = \@Dict({ data }) ->
List.map(data, (\(_, v) -> v)) List.map(data, \(_, v) -> v)
## Combine two dictionaries by keeping the [union](https://en.wikipedia.org/wiki/Union_(set_theory)) ## Combine two dictionaries by keeping the [union](https://en.wikipedia.org/wiki/Union_(set_theory))
## of all the key-value pairs. This means that all the key-value pairs in ## of all the key-value pairs. This means that all the key-value pairs in
@ -678,14 +687,17 @@ keep_shared = \xs0, ys0 ->
else else
(xs0, ys0) (xs0, ys0)
walk(xs1, with_capacity(len(xs1)), (\state, k, v -> walk(
when get(ys1, k) is xs1,
Ok(yv) if v == yv -> with_capacity(len(xs1)),
insert(state, k, v) \state, k, v ->
when get(ys1, k) is
Ok(yv) if v == yv ->
insert(state, k, v)
_ -> _ ->
state state,
)) )
## Remove the key-value pairs in the first input that are also in the second ## Remove the key-value pairs in the first input that are also in the second
## using the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement) ## using the [set difference](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement)
@ -709,7 +721,7 @@ keep_shared = \xs0, ys0 ->
## ``` ## ```
remove_all : Dict k v, Dict k v -> Dict k v remove_all : Dict k v, Dict k v -> Dict k v
remove_all = \xs, ys -> remove_all = \xs, ys ->
walk(ys, xs, (\state, k, _ -> remove(state, k))) walk(ys, xs, \state, k, _ -> remove(state, k))
# Below here is a list of generic helpers and internal data types for Dict # Below here is a list of generic helpers and internal data types for Dict
Bucket : { Bucket : {
@ -896,10 +908,13 @@ calc_num_buckets = \shifts ->
Num.min(Num.shift_left_by(1, Num.sub_wrap(64, shifts)), max_bucket_count) Num.min(Num.shift_left_by(1, Num.sub_wrap(64, shifts)), max_bucket_count)
fill_buckets_from_data = \buckets0, data, shifts -> fill_buckets_from_data = \buckets0, data, shifts ->
List.walk_with_index(data, buckets0, (\buckets1, (key, _), data_index -> List.walk_with_index(
(bucket_index, dist_and_fingerprint) = next_while_less(buckets1, key, shifts) data,
place_and_shift_up(buckets1, { dist_and_fingerprint, data_index: Num.to_u32(data_index) }, bucket_index) buckets0,
)) \buckets1, (key, _), data_index ->
(bucket_index, dist_and_fingerprint) = next_while_less(buckets1, key, shifts)
place_and_shift_up(buckets1, { dist_and_fingerprint, data_index: Num.to_u32(data_index) }, bucket_index),
)
next_while_less : List Bucket, k, U8 -> (U64, U32) where k implements Hash & Eq next_while_less : List Bucket, k, U8 -> (U64, U32) where k implements Hash & Eq
next_while_less = \buckets, key, shifts -> next_while_less = \buckets, key, shifts ->
@ -1056,7 +1071,7 @@ expect
|> insert("bar", {}) |> insert("bar", {})
|> insert("baz", {}) |> insert("baz", {})
contains(dict, "baz") && !contains(dict, "other") contains(dict, "baz") && !(contains(dict, "other"))
expect expect
dict = dict =
@ -1216,18 +1231,27 @@ expect
] ]
dict = dict =
List.walk(bad_keys, Dict.empty({}), (\acc, k -> List.walk(
Dict.update(acc, k, (\val -> bad_keys,
when val is Dict.empty({}),
Ok(p) -> Ok(Num.add_wrap(p, 1)) \acc, k ->
Err(Missing) -> Ok(0) Dict.update(
)) acc,
)) k,
\val ->
when val is
Ok(p) -> Ok(Num.add_wrap(p, 1))
Err(Missing) -> Ok(0),
),
)
all_inserted_correctly = all_inserted_correctly =
List.walk(bad_keys, Bool.true, (\acc, k -> List.walk(
acc && Dict.contains(dict, k) bad_keys,
)) Bool.true,
\acc, k ->
acc && Dict.contains(dict, k),
)
all_inserted_correctly all_inserted_correctly
@ -1324,10 +1348,10 @@ add_u32 = \@LowLevelHasher({ initialized_seed, state }), u32 ->
combine_state(@LowLevelHasher({ initialized_seed, state }), { a, b: a, seed: initialized_seed, length: 4 }) combine_state(@LowLevelHasher({ initialized_seed, state }), { a, b: a, seed: initialized_seed, length: 4 })
add_u64 = \@LowLevelHasher({ initialized_seed, state }), u64 -> add_u64 = \@LowLevelHasher({ initialized_seed, state }), u64 ->
p0 = Num.bitwise_and 0xFFFF_FFFF u64 p0 = Num.bitwise_and(0xFFFF_FFFF, u64)
p1 = Num.shift_right_zf_by u64 32 p1 = Num.shift_right_zf_by(u64, 32)
a = Num.shift_left_by p0 32 |> Num.bitwise_or p1 a = Num.shift_left_by(p0, 32) |> Num.bitwise_or(p1)
b = Num.shift_left_by p1 32 |> Num.bitwise_or p0 b = Num.shift_left_by(p1, 32) |> Num.bitwise_or(p0)
combine_state(@LowLevelHasher({ initialized_seed, state }), { a, b, seed: initialized_seed, length: 8 }) combine_state(@LowLevelHasher({ initialized_seed, state }), { a, b, seed: initialized_seed, length: 8 })
@ -1370,36 +1394,33 @@ add_bytes = \@LowLevelHasher({ initialized_seed, state }), list ->
hash_bytes_helper48 : U64, U64, U64, List U8, U64, U64 -> { a : U64, b : U64, seed : U64 } hash_bytes_helper48 : U64, U64, U64, List U8, U64, U64 -> { a : U64, b : U64, seed : U64 }
hash_bytes_helper48 = \seed, see1, see2, list, index, remaining -> hash_bytes_helper48 = \seed, see1, see2, list, index, remaining ->
# TODO: update!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! new_seed = wymix(Num.bitwise_xor(wyr8(list, index), wyp1), Num.bitwise_xor(wyr8(list, Num.add_wrap(index, 8)), seed))
new_seed = wymix (Num.bitwise_xor (wyr8 list index) wyp1) (Num.bitwise_xor (wyr8 list (Num.add_wrap index 8)) seed) new_see1 = wymix(Num.bitwise_xor(wyr8(list, Num.add_wrap(index, 16)), wyp2), Num.bitwise_xor(wyr8(list, Num.add_wrap(index, 24)), see1))
new_see1 = wymix (Num.bitwise_xor (wyr8 list (Num.add_wrap index 16)) wyp2) (Num.bitwise_xor (wyr8 list (Num.add_wrap index 24)) see1) new_see2 = wymix(Num.bitwise_xor(wyr8(list, Num.add_wrap(index, 32)), wyp3), Num.bitwise_xor(wyr8(list, Num.add_wrap(index, 40)), see2))
new_see2 = wymix (Num.bitwise_xor (wyr8 list (Num.add_wrap index 32)) wyp3) (Num.bitwise_xor (wyr8 list (Num.add_wrap index 40)) see2) new_remaining = Num.sub_wrap(remaining, 48)
new_remaining = Num.sub_wrap remaining 48 new_index = Num.add_wrap(index, 48)
new_index = Num.add_wrap index 48
if new_remaining > 48 then if new_remaining > 48 then
hash_bytes_helper48 new_seed new_see1 new_see2 list new_index new_remaining hash_bytes_helper48(new_seed, new_see1, new_see2, list, new_index, new_remaining)
else if new_remaining > 16 then else if new_remaining > 16 then
final_seed = Num.bitwise_xor new_see2 (Num.bitwise_xor new_see1 new_seed) final_seed = Num.bitwise_xor(new_see2, Num.bitwise_xor(new_see1, new_seed))
hash_bytes_helper16 final_seed list new_index new_remaining hash_bytes_helper16(final_seed, list, new_index, new_remaining)
else else
final_seed = Num.bitwise_xor new_see2 (Num.bitwise_xor new_see1 new_seed) final_seed = Num.bitwise_xor(new_see2, Num.bitwise_xor(new_see1, new_seed))
{ a: wyr8 list (Num.sub_wrap new_remaining 16 |> Num.add_wrap new_index), b: wyr8 list (Num.sub_wrap new_remaining 8 |> Num.add_wrap new_index), seed: final_seed } { a: wyr8(list, (Num.sub_wrap(new_remaining, 16) |> Num.add_wrap(new_index))), b: wyr8(list, (Num.sub_wrap(new_remaining, 8) |> Num.add_wrap(new_index))), seed: final_seed }
hash_bytes_helper16 : U64, List U8, U64, U64 -> { a : U64, b : U64, seed : U64 } hash_bytes_helper16 : U64, List U8, U64, U64 -> { a : U64, b : U64, seed : U64 }
hash_bytes_helper16 = \seed, list, index, remaining -> hash_bytes_helper16 = \seed, list, index, remaining ->
new_seed = wymix (Num.bitwise_xor (wyr8 list index) wyp1) (Num.bitwise_xor (wyr8 list (Num.add_wrap index 8)) seed) new_seed = wymix(Num.bitwise_xor(wyr8(list, index), wyp1), Num.bitwise_xor(wyr8(list, Num.add_wrap(index, 8)), seed))
new_remaining = Num.sub_wrap remaining 16 new_remaining = Num.sub_wrap(remaining, 16)
new_index = Num.add_wrap index 16 new_index = Num.add_wrap(index, 16)
if new_remaining <= 16 then if new_remaining <= 16 then
{ a: wyr8 list (Num.sub_wrap new_remaining 16 |> Num.add_wrap new_index), b: wyr8 list (Num.sub_wrap new_remaining 8 |> Num.add_wrap new_index), seed: new_seed } { a: wyr8(list, (Num.sub_wrap(new_remaining, 16) |> Num.add_wrap(new_index))), b: wyr8(list, (Num.sub_wrap(new_remaining, 8) |> Num.add_wrap(new_index))), seed: new_seed }
else else
hash_bytes_helper16 new_seed list new_index new_remaining hash_bytes_helper16(new_seed, list, new_index, new_remaining)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
wyp0 : U64 wyp0 : U64
wyp0 = 0xa0761d6478bd642f wyp0 = 0xa0761d6478bd642f
@ -1667,7 +1688,7 @@ expect
|> Dict.insert("Alice", 17) |> Dict.insert("Alice", 17)
|> Dict.insert("Bob", 18) |> Dict.insert("Bob", 18)
|> Dict.insert("Charlie", 19) |> Dict.insert("Charlie", 19)
|> Dict.walk_until(Bool.false, (\_, _, age -> if age >= 18 then Break(Bool.true) else Continue(Bool.false))) |> Dict.walk_until(Bool.false, \_, _, age -> if age >= 18 then Break(Bool.true) else Continue(Bool.false))
|> Bool.is_eq(Bool.true) |> Bool.is_eq(Bool.true)
expect expect
@ -1709,7 +1730,7 @@ expect
|> Dict.insert(2, 2) |> Dict.insert(2, 2)
|> Dict.insert(3, 3) |> Dict.insert(3, 3)
|> Dict.insert(4, 4) |> Dict.insert(4, 4)
|> Dict.keep_if(\(k, _v) -> !List.contains(keys_to_delete, k)) |> Dict.keep_if(\(k, _v) -> !(List.contains(keys_to_delete, k)))
d2 = d2 =
Dict.empty({}) Dict.empty({})
@ -1728,7 +1749,7 @@ expect
|> Dict.insert(2, 2) |> Dict.insert(2, 2)
|> Dict.insert(3, 3) |> Dict.insert(3, 3)
|> Dict.insert(4, 4) |> Dict.insert(4, 4)
|> Dict.keep_if(\(k, _v) -> !List.contains(keys_to_delete, k)) |> Dict.keep_if(\(k, _v) -> !(List.contains(keys_to_delete, k)))
d2 = d2 =
Dict.empty({}) Dict.empty({})

901
crates/compiler/load/tests/test_reporting.rs
View file

File diff suppressed because it is too large Load diff

146
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/AStar.roc vendored
View file

@ -1,111 +1,99 @@
interface AStar module [initial_model, reconstruct_path, update_cost, cheapest_open, astar, find_path]
exposes [initialModel, reconstructPath, updateCost, cheapestOpen, astar, findPath]
imports []
# a port of https://github.com/krisajenkins/elm-astar/blob/2.1.3/src/AStar/Generalised.elm # a port of https://github.com/krisajenkins/elm-astar/blob/2.1.3/src/AStar/Generalised.elm
Model position : Model position : {
{ evaluated : Set position evaluated : Set position,
, openSet : Set position open_set : Set position,
, costs : Map.Map position F64 costs : Map.Map position F64,
, cameFrom : Map.Map position position came_from : Map.Map position position,
} }
initial_model : position -> Model position
initial_model = \start -> {
evaluated: Set.empty({}),
open_set: Set.single(start),
costs: Dict.single(start, 0.0),
came_from: Map.empty,
}
initialModel : position -> Model position cheapest_open : (position -> F64), Model position -> Result position [KeyNotFound]*
initialModel = \start -> cheapest_open = \cost_function, model ->
{ evaluated : Set.empty {}
, openSet : Set.single start
, costs : Dict.single start 0.0
, cameFrom : Map.empty
}
folder = \res_smallest_so_far, position ->
when Map.get(model.costs, position) is
Err(e) ->
Err(e)
cheapestOpen : (position -> F64), Model position -> Result position [KeyNotFound]* Ok(cost) ->
cheapestOpen = \costFunction, model -> position_cost = cost_function(position)
folder = \resSmallestSoFar, position -> when res_smallest_so_far is
when Map.get model.costs position is Err(_) -> Ok({ position, cost: cost + position_cost })
Err e -> Ok(smallest_so_far) ->
Err e if position_cost + cost < smallest_so_far.cost then
Ok({ position, cost: cost + position_cost })
else
Ok(smallest_so_far)
Ok cost -> Set.walk(model.open_set, Err(KeyNotFound), folder)
positionCost = costFunction position |> Result.map(\x -> x.position)
when resSmallestSoFar is reconstruct_path : Map position position, position -> List position
Err _ -> Ok { position, cost: cost + positionCost } reconstruct_path = \came_from, goal ->
Ok smallestSoFar -> when Map.get(came_from, goal) is
if positionCost + cost < smallestSoFar.cost then Err(KeyNotFound) ->
Ok { position, cost: cost + positionCost }
else
Ok smallestSoFar
Set.walk model.openSet (Err KeyNotFound) folder
|> Result.map (\x -> x.position)
reconstructPath : Map position position, position -> List position
reconstructPath = \cameFrom, goal ->
when Map.get cameFrom goal is
Err KeyNotFound ->
[] []
Ok next -> Ok(next) ->
List.append (reconstructPath cameFrom next) goal List.append(reconstruct_path(came_from, next), goal)
updateCost : position, position, Model position -> Model position update_cost : position, position, Model position -> Model position
updateCost = \current, neighbour, model -> update_cost = \current, neighbour, model ->
newCameFrom = Map.insert model.cameFrom neighbour current new_came_from = Map.insert(model.came_from, neighbour, current)
newCosts = Map.insert model.costs neighbour distanceTo new_costs = Map.insert(model.costs, neighbour, distance_to)
distanceTo = reconstructPath newCameFrom neighbour distance_to =
|> List.len reconstruct_path(new_came_from, neighbour)
|> Num.toFrac |> List.len
|> Num.to_frac
newModel = { model & costs : newCosts , cameFrom : newCameFrom } new_model = { model & costs: new_costs, came_from: new_came_from }
when Map.get model.costs neighbour is when Map.get(model.costs, neighbour) is
Err KeyNotFound -> Err(KeyNotFound) ->
newModel new_model
Ok previousDistance ->
if distanceTo < previousDistance then
newModel
Ok(previous_distance) ->
if distance_to < previous_distance then
new_model
else else
model model
find_path : { cost_function : position, position -> F64, move_function : position -> Set position, start : position, end : position } -> Result (List position) [KeyNotFound]*
findPath : { costFunction: (position, position -> F64), moveFunction: (position -> Set position), start : position, end : position } -> Result (List position) [KeyNotFound]* find_path = \{ cost_function, move_function, start, end } ->
findPath = \{ costFunction, moveFunction, start, end } -> astar(cost_function, move_function, end, initial_model(start))
astar costFunction moveFunction end (initialModel start)
astar : (position, position -> F64), (position -> Set position), position, Model position -> [Err [KeyNotFound]*, Ok (List position)]* astar : (position, position -> F64), (position -> Set position), position, Model position -> [Err [KeyNotFound]*, Ok (List position)]*
astar = \costFn, moveFn, goal, model -> astar = \cost_fn, move_fn, goal, model ->
when cheapestOpen (\position -> costFn goal position) model is when cheapest_open(\position -> cost_fn(goal, position), model) is
Err _ -> Err(_) ->
Err KeyNotFound Err(KeyNotFound)
Ok current -> Ok(current) ->
if current == goal then if current == goal then
Ok (reconstructPath model.cameFrom goal) Ok(reconstruct_path(model.came_from, goal))
else else
model_popped = { model & open_set: Set.remove(model.open_set, current), evaluated: Set.insert(model.evaluated, current) }
modelPopped = { model & openSet : Set.remove model.openSet current, evaluated : Set.insert model.evaluated current } neighbours = move_fn(current)
neighbours = moveFn current new_neighbours = Set.difference(neighbours, model_popped.evaluated)
newNeighbours = Set.difference neighbours modelPopped.evaluated model_with_neighbours = { model_popped & open_set: Set.union(model_popped.open_set, new_neighbours) }
modelWithNeighbours = { modelPopped & openSet : Set.union modelPopped.openSet newNeighbours } model_with_costs = Set.walk(new_neighbours, model_with_neighbours, \md, nb -> update_cost(current, nb, md))
modelWithCosts = Set.walk newNeighbours modelWithNeighbours (\md, nb -> updateCost current nb md) astar(cost_fn, move_fn, goal, model_with_costs)
astar costFn moveFn goal modelWithCosts

4
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Dep1.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep1 module [three, str, Unit, Identity, one, two]
exposes [three, str, Unit, Identity, one, two]
imports []
import Dep3Blah exposing [foo] import Dep3Blah exposing [foo]

4
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Dep2.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep2 module [one, two, blah]
exposes [one, two, blah]
imports []
import Dep3Blah exposing [foo, bar] import Dep3Blah exposing [foo, bar]

4
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Dep3Blah.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep3Blah module [one, two, foo, bar]
exposes [one, two, foo, bar]
imports []
import Dep3Other import Dep3Other

4
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Dep3Other.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep3Other module [foo, bar]
exposes [foo, bar]
imports []
foo = "foo from Dep3Other" foo = "foo from Dep3Other"
bar = "bar from Dep3Other" bar = "bar from Dep3Other"

4
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/ImportAlias.roc vendored
View file

@ -1,6 +1,4 @@
interface ImportAlias module [unit]
exposes [unit]
imports []
import Dep1 import Dep1

14
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/ManualAttr.roc vendored
View file

@ -1,18 +1,16 @@
interface ManualAttr module []
exposes []
imports []
# manually replicates the Attr wrapping that uniqueness inference uses, to try and find out why they are different # manually replicates the Attr wrapping that uniqueness inference uses, to try and find out why they are different
# It is very important that there are no signatures here! elm uses an optimization that leads to less copying when # It is very important that there are no signatures here! elm uses an optimization that leads to less copying when
# signatures are given. # signatures are given.
map = map =
unAttr = \Attr _ foobar -> foobar un_attr = \Attr(_, foobar) -> foobar
r = Attr unknown "bar" r = Attr(unknown, "bar")
s = Attr unknown2 { left : Attr Shared "foo" } s = Attr(unknown2, { left: Attr(Shared, "foo") })
when True is when True is
_ -> { y : r } _ -> { y: r }
_ -> { y : (unAttr s).left } _ -> { y: (un_attr(s)).left }

4
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/OneDep.roc vendored
View file

@ -1,6 +1,4 @@
interface OneDep module [str]
exposes [str]
imports []
import Dep3Blah exposing [foo] import Dep3Blah exposing [foo]

18
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Primary.roc vendored
View file

@ -1,6 +1,4 @@
interface Primary module [blah2, blah3, str, always_three, identity, z, w, succeed, with_default, yay]
exposes [blah2, blah3, str, alwaysThree, identity, z, w, succeed, withDefault, yay]
imports []
import Dep1 import Dep1
import Dep2 import Dep2
@ -12,24 +10,24 @@ blah3 = bar
str = Dep1.str str = Dep1.str
alwaysThree = \_ -> Dep1.three always_three = \_ -> Dep1.three
identity = \a -> a identity = \a -> a
z = identity (alwaysThree {}) z = identity(always_three({}))
w : Dep1.Identity {} w : Dep1.Identity {}
w = Identity {} w = Identity({})
succeed : a -> Dep1.Identity a succeed : a -> Dep1.Identity a
succeed = \x -> Identity x succeed = \x -> Identity(x)
withDefault = Res.withDefault with_default = Res.with_default
yay : Res.Res {} err yay : Res.Res {} err
yay = yay =
ok = Ok "foo" ok = Ok("foo")
f = \_ -> {} f = \_ -> {}
Res.map ok f Res.map(ok, f)

55
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Quicksort.roc vendored
View file

@ -1,49 +1,46 @@
app "quicksort" provides [swap, partition, partitionHelp, quicksort] to "./platform" app [swap, partition, partition_help, quicksort] {}
quicksort : List (Num a), U64, U64 -> List (Num a) quicksort : List (Num a), U64, U64 -> List (Num a)
quicksort = \list, low, high -> quicksort = \list, low, high ->
when partition low high list is when partition(low, high, list) is
Pair partitionIndex partitioned -> Pair(partition_index, partitioned) ->
partitioned partitioned
|> quicksort low (partitionIndex - 1) |> quicksort(low, (partition_index - 1))
|> quicksort (partitionIndex + 1) high |> quicksort((partition_index + 1), high)
swap : U64, U64, List a -> List a swap : U64, U64, List a -> List a
swap = \i, j, list -> swap = \i, j, list ->
when Pair (List.get list i) (List.get list j) is when Pair(List.get(list, i), List.get(list, j)) is
Pair (Ok atI) (Ok atJ) -> Pair(Ok(at_i), Ok(at_j)) ->
list list
|> List.set i atJ |> List.set(i, at_j)
|> List.set j atI |> List.set(j, at_i)
_ -> _ ->
[] []
partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))] partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))]
partition = \low, high, initialList -> partition = \low, high, initial_list ->
when List.get initialList high is when List.get(initial_list, high) is
Ok pivot -> Ok(pivot) ->
when partitionHelp (low - 1) low initialList high pivot is when partition_help((low - 1), low, initial_list, high, pivot) is
Pair newI newList -> Pair(new_i, new_list) ->
Pair (newI + 1) (swap (newI + 1) high newList) Pair((new_i + 1), swap((new_i + 1), high, new_list))
Err _ -> Err(_) ->
Pair (low - 1) initialList Pair((low - 1), initial_list)
partition_help : U64, U64, List (Num a), U64, Num a -> [Pair U64 (List (Num a))]
partitionHelp : U64, U64, List (Num a), U64, (Num a) -> [Pair U64 (List (Num a))] partition_help = \i, j, list, high, pivot ->
partitionHelp = \i, j, list, high, pivot ->
if j < high then if j < high then
when List.get list j is when List.get(list, j) is
Ok value -> Ok(value) ->
if value <= pivot then if value <= pivot then
partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot partition_help((i + 1), (j + 1), swap((i + 1), j, list), high, pivot)
else else
partitionHelp i (j + 1) list high pivot partition_help(i, (j + 1), list, high, pivot)
Err _ -> Err(_) ->
Pair i list Pair(i, list)
else else
Pair i list Pair(i, list)

66
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/QuicksortMultiDef.roc vendored
View file

@ -1,57 +1,53 @@
app "quicksort" provides [quicksort] to "./platform" app [quicksort] {}
quicksortHelp : List (Num a), U64, U64 -> List (Num a) quicksort_help : List (Num a), U64, U64 -> List (Num a)
quicksortHelp = \list, low, high -> quicksort_help = \list, low, high ->
if low < high then if low < high then
when partition low high list is when partition(low, high, list) is
Pair partitionIndex partitioned -> Pair(partition_index, partitioned) ->
partitioned partitioned
|> quicksortHelp low (partitionIndex - 1) |> quicksort_help(low, (partition_index - 1))
|> quicksortHelp (partitionIndex + 1) high |> quicksort_help((partition_index + 1), high)
else else
list list
swap : U64, U64, List a -> List a swap : U64, U64, List a -> List a
swap = \i, j, list -> swap = \i, j, list ->
when Pair (List.get list i) (List.get list j) is when Pair(List.get(list, i), List.get(list, j)) is
Pair (Ok atI) (Ok atJ) -> Pair(Ok(at_i), Ok(at_j)) ->
list list
|> List.set i atJ |> List.set(i, at_j)
|> List.set j atI |> List.set(j, at_i)
_ -> _ ->
[] []
partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))] partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))]
partition = \low, high, initialList -> partition = \low, high, initial_list ->
when List.get initialList high is when List.get(initial_list, high) is
Ok pivot -> Ok(pivot) ->
when partitionHelp (low - 1) low initialList high pivot is when partition_help((low - 1), low, initial_list, high, pivot) is
Pair newI newList -> Pair(new_i, new_list) ->
Pair (newI + 1) (swap (newI + 1) high newList) Pair((new_i + 1), swap((new_i + 1), high, new_list))
Err _ -> Err(_) ->
Pair (low - 1) initialList Pair((low - 1), initial_list)
partition_help : U64, U64, List (Num a), U64, Num a -> [Pair U64 (List (Num a))]
partitionHelp : U64, U64, List (Num a), U64, (Num a) -> [Pair U64 (List (Num a))] partition_help = \i, j, list, high, pivot ->
partitionHelp = \i, j, list, high, pivot ->
if j < high then if j < high then
when List.get list j is when List.get(list, j) is
Ok value -> Ok(value) ->
if value <= pivot then if value <= pivot then
partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot partition_help((i + 1), (j + 1), swap((i + 1), j, list), high, pivot)
else else
partitionHelp i (j + 1) list high pivot partition_help(i, (j + 1), list, high, pivot)
Err _ -> Err(_) ->
Pair i list Pair(i, list)
else else
Pair i list Pair(i, list)
quicksort = \original_list ->
n = List.len(original_list)
quicksort = \originalList -> quicksort_help(original_list, 0, (n - 1))
n = List.len originalList
quicksortHelp originalList 0 (n - 1)

8
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Records.roc vendored
View file

@ -1,8 +1,6 @@
interface Records module [int_val]
exposes [intVal]
imports []
intVal = int_val =
foo = \{ x } -> x foo = \{ x } -> x
foo { x: 5 } foo({ x: 5 })

34
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/Res.roc vendored
View file

@ -1,31 +1,29 @@
interface Res module [Res, with_default, map, and_then, ConsList]
exposes [Res, withDefault, map, andThen, ConsList]
imports []
Res ok err : [Ok ok, Err err] Res ok err : [Ok ok, Err err]
ConsList a : [Cons a (ConsList a), Nil] ConsList a : [Cons a (ConsList a), Nil]
listMap : ConsList a, (a -> b) -> ConsList b list_map : ConsList a, (a -> b) -> ConsList b
listMap = \list, f -> list_map = \list, f ->
when list is when list is
Nil -> Nil Nil -> Nil
Cons x xs -> Cons (f x) (listMap xs f) Cons(x, xs) -> Cons(f(x), list_map(xs, f))
map : Res a err, (a -> b) -> Res b err map : Res a err, (a -> b) -> Res b err
map = \result, transform -> map = \result, transform ->
when result is when result is
Ok ok -> Ok (transform ok) Ok(ok) -> Ok(transform(ok))
Err err -> Err err Err(err) -> Err(err)
withDefault : Res a err, a -> a with_default : Res a err, a -> a
withDefault = \result, default -> with_default = \result, default ->
when result is when result is
Ok ok -> ok Ok(ok) -> ok
Err _ -> default Err(_) -> default
andThen : Res a err, (a -> Res b err) -> Res b err and_then : Res a err, (a -> Res b err) -> Res b err
andThen = \result, transform -> and_then = \result, transform ->
when result is when result is
Ok ok -> transform ok Ok(ok) -> transform(ok)
Err err -> Err err Err(err) -> Err(err)

18
crates/compiler/load_internal/tests/fixtures/build/app_with_deps/WithBuiltins.roc vendored
View file

@ -1,22 +1,20 @@
interface WithBuiltins module [float_test, division_fn, division_test, int_test, constant_num, from_dep2, div_dep1_by_dep2]
exposes [floatTest, divisionFn, divisionTest, intTest, constantNum, fromDep2, divDep1ByDep2]
imports []
import Dep1 import Dep1
import Dep2 exposing [two] import Dep2 exposing [two]
floatTest = Num.maxF64 float_test = Num.max_f64
divisionFn = Num.div division_fn = Num.div
x = 5.0 x = 5.0
divisionTest = Num.maxF64 / x division_test = Num.max_f64 / x
intTest = Num.maxI64 int_test = Num.max_i64
constantNum = 5 constant_num = 5
fromDep2 = Dep2.two from_dep2 = Dep2.two
divDep1ByDep2 = Dep1.three / fromDep2 div_dep1_by_dep2 = Dep1.three / from_dep2

146
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/AStar.roc vendored
View file

@ -1,111 +1,99 @@
interface AStar module [initial_model, reconstruct_path, update_cost, cheapest_open, astar, find_path]
exposes [initialModel, reconstructPath, updateCost, cheapestOpen, astar, findPath]
imports []
# a port of https://github.com/krisajenkins/elm-astar/blob/2.1.3/src/AStar/Generalised.elm # a port of https://github.com/krisajenkins/elm-astar/blob/2.1.3/src/AStar/Generalised.elm
Model position : Model position : {
{ evaluated : Set position evaluated : Set position,
, openSet : Set position open_set : Set position,
, costs : Dict.Dict position F64 costs : Dict.Dict position F64,
, cameFrom : Dict.Dict position position came_from : Dict.Dict position position,
} }
initial_model : position -> Model position where position implements Hash & Eq
initial_model = \start -> {
evaluated: Set.empty({}),
open_set: Set.single(start),
costs: Dict.single(start, 0.0),
came_from: Dict.empty({}),
}
initialModel : position -> Model position where position implements Hash & Eq cheapest_open : (position -> F64), Model position -> Result position [KeyNotFound] where position implements Hash & Eq
initialModel = \start -> cheapest_open = \cost_function, model ->
{ evaluated : Set.empty {}
, openSet : Set.single start
, costs : Dict.single start 0.0
, cameFrom : Dict.empty {}
}
folder = \res_smallest_so_far, position ->
when Dict.get(model.costs, position) is
Err(e) ->
Err(e)
cheapestOpen : (position -> F64), Model position -> Result position [KeyNotFound] where position implements Hash & Eq Ok(cost) ->
cheapestOpen = \costFunction, model -> position_cost = cost_function(position)
folder = \resSmallestSoFar, position -> when res_smallest_so_far is
when Dict.get model.costs position is Err(_) -> Ok({ position, cost: cost + position_cost })
Err e -> Ok(smallest_so_far) ->
Err e if position_cost + cost < smallest_so_far.cost then
Ok({ position, cost: cost + position_cost })
else
Ok(smallest_so_far)
Ok cost -> Set.walk(model.open_set, Err(KeyNotFound), folder)
positionCost = costFunction position |> Result.map(\x -> x.position)
when resSmallestSoFar is reconstruct_path : Dict position position, position -> List position where position implements Hash & Eq
Err _ -> Ok { position, cost: cost + positionCost } reconstruct_path = \came_from, goal ->
Ok smallestSoFar -> when Dict.get(came_from, goal) is
if positionCost + cost < smallestSoFar.cost then Err(KeyNotFound) ->
Ok { position, cost: cost + positionCost }
else
Ok smallestSoFar
Set.walk model.openSet (Err KeyNotFound) folder
|> Result.map (\x -> x.position)
reconstructPath : Dict position position, position -> List position where position implements Hash & Eq
reconstructPath = \cameFrom, goal ->
when Dict.get cameFrom goal is
Err KeyNotFound ->
[] []
Ok next -> Ok(next) ->
List.append (reconstructPath cameFrom next) goal List.append(reconstruct_path(came_from, next), goal)
updateCost : position, position, Model position -> Model position where position implements Hash & Eq update_cost : position, position, Model position -> Model position where position implements Hash & Eq
updateCost = \current, neighbour, model -> update_cost = \current, neighbour, model ->
newCameFrom = Dict.insert model.cameFrom neighbour current new_came_from = Dict.insert(model.came_from, neighbour, current)
newCosts = Dict.insert model.costs neighbour distanceTo new_costs = Dict.insert(model.costs, neighbour, distance_to)
distanceTo = reconstructPath newCameFrom neighbour distance_to =
|> List.len reconstruct_path(new_came_from, neighbour)
|> Num.toFrac |> List.len
|> Num.to_frac
newModel = { model & costs : newCosts , cameFrom : newCameFrom } new_model = { model & costs: new_costs, came_from: new_came_from }
when Dict.get model.costs neighbour is when Dict.get(model.costs, neighbour) is
Err KeyNotFound -> Err(KeyNotFound) ->
newModel new_model
Ok previousDistance ->
if distanceTo < previousDistance then
newModel
Ok(previous_distance) ->
if distance_to < previous_distance then
new_model
else else
model model
find_path : { cost_function : position, position -> F64, move_function : position -> Set position, start : position, end : position } -> Result (List position) [KeyNotFound] where position implements Hash & Eq
findPath : { costFunction: (position, position -> F64), moveFunction: (position -> Set position), start : position, end : position } -> Result (List position) [KeyNotFound] where position implements Hash & Eq find_path = \{ cost_function, move_function, start, end } ->
findPath = \{ costFunction, moveFunction, start, end } -> astar(cost_function, move_function, end, initial_model(start))
astar costFunction moveFunction end (initialModel start)
astar : (position, position -> F64), (position -> Set position), position, Model position -> [Err [KeyNotFound], Ok (List position)] where position implements Hash & Eq astar : (position, position -> F64), (position -> Set position), position, Model position -> [Err [KeyNotFound], Ok (List position)] where position implements Hash & Eq
astar = \costFn, moveFn, goal, model -> astar = \cost_fn, move_fn, goal, model ->
when cheapestOpen (\position -> costFn goal position) model is when cheapest_open(\position -> cost_fn(goal, position), model) is
Err _ -> Err(_) ->
Err KeyNotFound Err(KeyNotFound)
Ok current -> Ok(current) ->
if current == goal then if current == goal then
Ok (reconstructPath model.cameFrom goal) Ok(reconstruct_path(model.came_from, goal))
else else
model_popped = { model & open_set: Set.remove(model.open_set, current), evaluated: Set.insert(model.evaluated, current) }
modelPopped = { model & openSet : Set.remove model.openSet current, evaluated : Set.insert model.evaluated current } neighbours = move_fn(current)
neighbours = moveFn current new_neighbours = Set.difference(neighbours, model_popped.evaluated)
newNeighbours = Set.difference neighbours modelPopped.evaluated model_with_neighbours = { model_popped & open_set: Set.union(model_popped.open_set, new_neighbours) }
modelWithNeighbours = { modelPopped & openSet : Set.union modelPopped.openSet newNeighbours } model_with_costs = Set.walk(new_neighbours, model_with_neighbours, \md, nb -> update_cost(current, nb, md))
modelWithCosts = Set.walk newNeighbours modelWithNeighbours (\md, nb -> updateCost current nb md) astar(cost_fn, move_fn, goal, model_with_costs)
astar costFn moveFn goal modelWithCosts

4
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Dep1.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep1 module [three, str, Unit, Identity, one, two]
exposes [three, str, Unit, Identity, one, two]
imports []
import Dep3 exposing [foo] import Dep3 exposing [foo]

4
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Dep2.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep2 module [one, two, blah]
exposes [one, two, blah]
imports []
import Dep3 exposing [foo, bar] import Dep3 exposing [foo, bar]

4
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Dep3.roc vendored
View file

@ -1,6 +1,4 @@
interface Dep3 module [one, two, foo, bar]
exposes [one, two, foo, bar]
imports []
one = 1 one = 1

2
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/ExposedUsedOutsideScope.roc vendored
View file

@ -1,4 +1,4 @@
interface ExposedUsedOutsideScope exposes [good, bad] imports [] module [good, bad]
good = good =
import Dep2 exposing [two] import Dep2 exposing [two]

4
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/ImportAlias.roc vendored
View file

@ -1,6 +1,4 @@
interface ImportAlias module [unit]
exposes [unit]
imports []
import Dep1 import Dep1

6
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/ImportInsideDef.roc vendored
View file

@ -1,10 +1,10 @@
interface ImportInsideDef exposes [dep1Str, dep2TwoDobuled] imports [] module [dep1_str, dep2_two_dobuled]
dep1Str = dep1_str =
import Dep1 import Dep1
Dep1.str Dep1.str
dep2TwoDobuled = dep2_two_dobuled =
2 2
* ( * (
import Dep2 exposing [two] import Dep2 exposing [two]

2
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/ImportUsedOutsideScope.roc vendored
View file

@ -1,4 +1,4 @@
interface ImportUsedOutsideScope exposes [good, bad] imports [] module [good, bad]
good = good =
import Dep2 import Dep2

4
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/IngestedFile.roc vendored
View file

@ -1,6 +1,4 @@
interface IngestedFile module [str, nested]
exposes [str, nested]
imports []
import "IngestedFile.roc" as foo : Str import "IngestedFile.roc" as foo : Str

6
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/IngestedFileBytes.roc vendored
View file

@ -1,7 +1,5 @@
interface IngestedFileBytes module [str]
exposes [str]
imports []
import "IngestedFileBytes.roc" as foo : List U8 import "IngestedFileBytes.roc" as foo : List U8
str = Str.fromUtf8 foo |> Result.withDefault "" str = Str.from_utf8(foo) |> Result.with_default("")

14
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/ManualAttr.roc vendored
View file

@ -1,18 +1,16 @@
interface ManualAttr module []
exposes []
imports []
# manually replicates the Attr wrapping that uniqueness inference uses, to try and find out why they are different # manually replicates the Attr wrapping that uniqueness inference uses, to try and find out why they are different
# It is very important that there are no signatures here! elm uses an optimization that leads to less copying when # It is very important that there are no signatures here! elm uses an optimization that leads to less copying when
# signatures are given. # signatures are given.
map = map =
unAttr = \Attr _ foobar -> foobar un_attr = \Attr(_, foobar) -> foobar
r = Attr unknown "bar" r = Attr(unknown, "bar")
s = Attr unknown2 { left : Attr Shared "foo" } s = Attr(unknown2, { left: Attr(Shared, "foo") })
when True is when True is
_ -> { y : r } _ -> { y: r }
_ -> { y : (unAttr s).left } _ -> { y: (un_attr(s)).left }

4
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/OneDep.roc vendored
View file

@ -1,6 +1,4 @@
interface OneDep module [str]
exposes [str]
imports []
import Dep3 exposing [foo] import Dep3 exposing [foo]

18
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Primary.roc vendored
View file

@ -1,6 +1,4 @@
interface Primary module [blah2, blah3, str, always_three, identity, z, w, succeed, with_default, yay]
exposes [blah2, blah3, str, alwaysThree, identity, z, w, succeed, withDefault, yay]
imports []
import Dep1 import Dep1
import Dep2 import Dep2
@ -12,24 +10,24 @@ blah3 = bar
str = Dep1.str str = Dep1.str
alwaysThree = \_ -> Dep1.three always_three = \_ -> Dep1.three
identity = \a -> a identity = \a -> a
z = identity (alwaysThree {}) z = identity(always_three({}))
w : Dep1.Identity {} w : Dep1.Identity {}
w = Identity {} w = Identity({})
succeed : a -> Dep1.Identity a succeed : a -> Dep1.Identity a
succeed = \x -> Identity x succeed = \x -> Identity(x)
withDefault = Res.withDefault with_default = Res.with_default
yay : Res.Res {} err yay : Res.Res {} err
yay = yay =
ok = Ok "foo" ok = Ok("foo")
f = \_ -> {} f = \_ -> {}
Res.map ok f Res.map(ok, f)

57
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Quicksort.roc vendored
View file

@ -1,51 +1,46 @@
interface Quicksort module [swap, partition, quicksort]
exposes [swap, partition, quicksort]
imports []
quicksort : List (Num a), U64, U64 -> List (Num a) quicksort : List (Num a), U64, U64 -> List (Num a)
quicksort = \list, low, high -> quicksort = \list, low, high ->
when partition low high list is when partition(low, high, list) is
Pair partitionIndex partitioned -> Pair(partition_index, partitioned) ->
partitioned partitioned
|> quicksort low (partitionIndex - 1) |> quicksort(low, (partition_index - 1))
|> quicksort (partitionIndex + 1) high |> quicksort((partition_index + 1), high)
swap : U64, U64, List a -> List a swap : U64, U64, List a -> List a
swap = \i, j, list -> swap = \i, j, list ->
when Pair (List.get list i) (List.get list j) is when Pair(List.get(list, i), List.get(list, j)) is
Pair (Ok atI) (Ok atJ) -> Pair(Ok(at_i), Ok(at_j)) ->
list list
|> List.set i atJ |> List.set(i, at_j)
|> List.set j atI |> List.set(j, at_i)
_ -> _ ->
[] []
partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))] partition : U64, U64, List (Num a) -> [Pair U64 (List (Num a))]
partition = \low, high, initialList -> partition = \low, high, initial_list ->
when List.get initialList high is when List.get(initial_list, high) is
Ok pivot -> Ok(pivot) ->
when partitionHelp (low - 1) low initialList high pivot is when partition_help((low - 1), low, initial_list, high, pivot) is
Pair newI newList -> Pair(new_i, new_list) ->
Pair (newI + 1) (swap (newI + 1) high newList) Pair((new_i + 1), swap((new_i + 1), high, new_list))
Err _ -> Err(_) ->
Pair (low - 1) initialList Pair((low - 1), initial_list)
partition_help : U64, U64, List (Num a), U64, Num a -> [Pair U64 (List (Num a))]
partitionHelp : U64, U64, List (Num a), U64, (Num a) -> [Pair U64 (List (Num a))] partition_help = \i, j, list, high, pivot ->
partitionHelp = \i, j, list, high, pivot ->
if j < high then if j < high then
when List.get list j is when List.get(list, j) is
Ok value -> Ok(value) ->
if value <= pivot then if value <= pivot then
partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot partition_help((i + 1), (j + 1), swap((i + 1), j, list), high, pivot)
else else
partitionHelp i (j + 1) list high pivot partition_help(i, (j + 1), list, high, pivot)
Err _ -> Err(_) ->
Pair i list Pair(i, list)
else else
Pair i list Pair(i, list)

8
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Records.roc vendored
View file

@ -1,8 +1,6 @@
interface Records module [int_val]
exposes [intVal]
imports []
intVal = int_val =
foo = \{ x } -> x foo = \{ x } -> x
foo { x: 5 } foo({ x: 5 })

34
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/Res.roc vendored
View file

@ -1,31 +1,29 @@
interface Res module [Res, with_default, map, list_map, and_then, ConsList]
exposes [Res, withDefault, map, listMap, andThen, ConsList]
imports []
Res ok err : [Ok ok, Err err] Res ok err : [Ok ok, Err err]
ConsList a : [Cons a (ConsList a), Nil] ConsList a : [Cons a (ConsList a), Nil]
listMap : ConsList a, (a -> b) -> ConsList b list_map : ConsList a, (a -> b) -> ConsList b
listMap = \list, f -> list_map = \list, f ->
when list is when list is
Nil -> Nil Nil -> Nil
Cons x xs -> Cons (f x) (listMap xs f) Cons(x, xs) -> Cons(f(x), list_map(xs, f))
map : Res a err, (a -> b) -> Res b err map : Res a err, (a -> b) -> Res b err
map = \result, transform -> map = \result, transform ->
when result is when result is
Ok ok -> Ok (transform ok) Ok(ok) -> Ok(transform(ok))
Err err -> Err err Err(err) -> Err(err)
withDefault : Res a err, a -> a with_default : Res a err, a -> a
withDefault = \result, default -> with_default = \result, default ->
when result is when result is
Ok ok -> ok Ok(ok) -> ok
Err _ -> default Err(_) -> default
andThen : Res a err, (a -> Res b err) -> Res b err and_then : Res a err, (a -> Res b err) -> Res b err
andThen = \result, transform -> and_then = \result, transform ->
when result is when result is
Ok ok -> transform ok Ok(ok) -> transform(ok)
Err err -> Err err Err(err) -> Err(err)

18
crates/compiler/load_internal/tests/fixtures/build/module_with_deps/WithBuiltins.roc vendored
View file

@ -1,22 +1,20 @@
interface WithBuiltins module [float_test, division_fn, division_test, int_test, constant_num, from_dep2, div_dep1_by_dep2]
exposes [floatTest, divisionFn, divisionTest, intTest, constantNum, fromDep2, divDep1ByDep2]
imports []
import Dep1 import Dep1
import Dep2 import Dep2
floatTest = Num.maxF64 float_test = Num.max_f64
divisionFn = Num.div division_fn = Num.div
x = 5.0 x = 5.0
divisionTest = Num.maxF64 / x division_test = Num.max_f64 / x
intTest = Num.maxI64 int_test = Num.max_i64
constantNum = 5 constant_num = 5
fromDep2 = Dep2.two from_dep2 = Dep2.two
divDep1ByDep2 = Dep1.three / fromDep2 div_dep1_by_dep2 = Dep1.three / from_dep2

12
crates/compiler/load_internal/tests/fixtures/build/no_deps/Docs.roc vendored
View file

@ -1,7 +1,5 @@
## An interface for docs tests ## An interface for docs tests
interface Docs module [make_user, get_name_exposed]
exposes [makeUser, getNameExposed]
imports []
## This is a user ## This is a user
User : { name : Str } User : { name : Str }
@ -9,12 +7,12 @@ User : { name : Str }
## Makes a user ## Makes a user
## ##
## Takes a name Str. ## Takes a name Str.
makeUser : Str -> User make_user : Str -> User
makeUser = \name -> make_user = \name ->
{ name } { name }
## Gets the user's name ## Gets the user's name
getName = \a -> a.name get_name = \a -> a.name
getNameExposed = getName get_name_exposed = get_name

4
crates/compiler/load_internal/tests/fixtures/build/no_deps/MissingDep.roc vendored
View file

@ -1,6 +1,4 @@
interface MissingDep module [unit]
exposes [unit]
imports []
import ThisFileIsMissing import ThisFileIsMissing

4
crates/compiler/load_internal/tests/fixtures/build/no_deps/MissingIngestedFile.roc vendored
View file

@ -1,6 +1,4 @@
interface MissingIngestedFile module [unit]
exposes [unit]
imports []
import "ThisFileIsMissing" as data : List U8 import "ThisFileIsMissing" as data : List U8

6
crates/compiler/load_internal/tests/fixtures/build/no_deps/Principal.roc vendored
View file

@ -1,7 +1,5 @@
interface Principal module [identity, int_val]
exposes [identity, intVal]
imports []
identity = \a -> a identity = \a -> a
intVal = identity "hi" int_val = identity("hi")

4
crates/compiler/load_internal/tests/fixtures/build/no_deps/Unit.roc vendored
View file

@ -1,6 +1,4 @@
interface Unit module [unit]
exposes [unit]
imports []
Unit : [Unit] Unit : [Unit]

82
crates/compiler/load_internal/tests/test_load.rs
View file

@ -512,11 +512,11 @@ fn load_docs() {
(None, Some("An interface for docs tests\n")), (None, Some("An interface for docs tests\n")),
(Some("User"), Some("This is a user\n")), (Some("User"), Some("This is a user\n")),
( (
Some("makeUser"), Some("make_user"),
Some("Makes a user\n\nTakes a name Str.\n"), Some("Makes a user\n\nTakes a name Str.\n"),
), ),
(Some("getName"), Some("Gets the user's name\n")), (Some("get_name"), Some("Gets the user's name\n")),
(Some("getNameExposed"), None), (Some("get_name_exposed"), None),
] ]
.into_iter() .into_iter()
.map(|(ident_str_opt, doc_str_opt)| { .map(|(ident_str_opt, doc_str_opt)| {
@ -553,8 +553,8 @@ fn import_inside_def() {
expect_types( expect_types(
loaded_module, loaded_module,
hashmap! { hashmap! {
"dep1Str" => "Str", "dep1_str" => "Str",
"dep2TwoDobuled" => "Frac *", "dep2_two_dobuled" => "Frac *",
}, },
); );
} }
@ -585,15 +585,15 @@ fn test_load_and_typecheck() {
expect_types( expect_types(
loaded_module, loaded_module,
hashmap! { hashmap! {
"floatTest" => "F64", "float_test" => "F64",
"divisionFn" => "Frac a, Frac a -> Frac a", "division_fn" => "Frac a, Frac a -> Frac a",
"x" => "Frac *", "x" => "Frac *",
"divisionTest" => "F64", "division_test" => "F64",
"intTest" => "I64", "int_test" => "I64",
"constantNum" => "Num *", "constant_num" => "Num *",
"divisionTest" => "F64", "division_test" => "F64",
"divDep1ByDep2" => "Frac a", "div_dep1_by_dep2" => "Frac a",
"fromDep2" => "Frac a", "from_dep2" => "Frac a",
}, },
); );
} }
@ -608,7 +608,7 @@ fn iface_quicksort() {
hashmap! { hashmap! {
"swap" => "U64, U64, List a -> List a", "swap" => "U64, U64, List a -> List a",
"partition" => "U64, U64, List (Num a) -> [Pair U64 (List (Num a))]", "partition" => "U64, U64, List (Num a) -> [Pair U64 (List (Num a))]",
"partitionHelp" => "U64, U64, List (Num a), U64, Num a -> [Pair U64 (List (Num a))]", "partition_help" => "U64, U64, List (Num a), U64, Num a -> [Pair U64 (List (Num a))]",
"quicksort" => "List (Num a), U64, U64 -> List (Num a)", "quicksort" => "List (Num a), U64, U64 -> List (Num a)",
}, },
); );
@ -622,11 +622,11 @@ fn load_astar() {
expect_types( expect_types(
loaded_module, loaded_module,
hashmap! { hashmap! {
"findPath" => "{ costFunction : position, position -> F64, end : position, moveFunction : position -> Set position, start : position } -> Result (List position) [KeyNotFound] where position implements Hash & Eq", "find_path" => "{ cost_function : position, position -> F64, end : position, move_function : position -> Set position, start : position } -> Result (List position) [KeyNotFound] where position implements Hash & Eq",
"initialModel" => "position -> Model position where position implements Hash & Eq", "initial_model" => "position -> Model position where position implements Hash & Eq",
"reconstructPath" => "Dict position position, position -> List position where position implements Hash & Eq", "reconstruct_path" => "Dict position position, position -> List position where position implements Hash & Eq",
"updateCost" => "position, position, Model position -> Model position where position implements Hash & Eq", "update_cost" => "position, position, Model position -> Model position where position implements Hash & Eq",
"cheapestOpen" => "(position -> F64), Model position -> Result position [KeyNotFound] where position implements Hash & Eq", "cheapest_open" => "(position -> F64), Model position -> Result position [KeyNotFound] where position implements Hash & Eq",
"astar" => "(position, position -> F64), (position -> Set position), position, Model position -> [Err [KeyNotFound], Ok (List position)] where position implements Hash & Eq", "astar" => "(position, position -> F64), (position -> Set position), position, Model position -> [Err [KeyNotFound], Ok (List position)] where position implements Hash & Eq",
}, },
); );
@ -640,7 +640,7 @@ fn load_principal_types() {
expect_types( expect_types(
loaded_module, loaded_module,
hashmap! { hashmap! {
"intVal" => "Str", "int_val" => "Str",
"identity" => "a -> a", "identity" => "a -> a",
}, },
); );
@ -657,13 +657,13 @@ fn iface_dep_types() {
"blah2" => "Frac *", "blah2" => "Frac *",
"blah3" => "Str", "blah3" => "Str",
"str" => "Str", "str" => "Str",
"alwaysThree" => "* -> Frac *", "always_three" => "* -> Frac *",
"identity" => "a -> a", "identity" => "a -> a",
"z" => "Frac *", "z" => "Frac *",
"w" => "Dep1.Identity {}", "w" => "Dep1.Identity {}",
"succeed" => "a -> Dep1.Identity a", "succeed" => "a -> Dep1.Identity a",
"yay" => "Res.Res {} err", "yay" => "Res.Res {} err",
"withDefault" => "Res.Res a err, a -> a", "with_default" => "Res.Res a err, a -> a",
}, },
); );
} }
@ -679,13 +679,13 @@ fn app_dep_types() {
"blah2" => "Frac *", "blah2" => "Frac *",
"blah3" => "Str", "blah3" => "Str",
"str" => "Str", "str" => "Str",
"alwaysThree" => "* -> Frac *", "always_three" => "* -> Frac *",
"identity" => "a -> a", "identity" => "a -> a",
"z" => "Frac *", "z" => "Frac *",
"w" => "Dep1.Identity {}", "w" => "Dep1.Identity {}",
"succeed" => "a -> Dep1.Identity a", "succeed" => "a -> Dep1.Identity a",
"yay" => "Res.Res {} err", "yay" => "Res.Res {} err",
"withDefault" => "Res.Res a err, a -> a", "with_default" => "Res.Res a err, a -> a",
}, },
); );
} }
@ -897,13 +897,13 @@ fn opaque_wrapped_unwrapped_outside_defining_module() {
"Main.roc", "Main.roc",
indoc!( indoc!(
r" r"
module [twenty, readAge] module [twenty, read_age]
import Age exposing [Age] import Age exposing [Age]
twenty = @Age 20 twenty = @Age 20
readAge = \@Age n -> n read_age = \@Age n -> n
" "
), ),
), ),
@ -933,8 +933,8 @@ fn opaque_wrapped_unwrapped_outside_defining_module() {
The unwrapped opaque type Age referenced here: The unwrapped opaque type Age referenced here:
7│ readAge = \@Age n -> n 7│ read_age = \@Age n -> n
^^^^ ^^^^
is imported from another module: is imported from another module:
@ -997,27 +997,27 @@ fn unused_imports() {
"Main.roc", "Main.roc",
indoc!( indoc!(
r#" r#"
module [usedModule, unusedModule, unusedExposed, usingThreeValue, unusedWithAlias] module [used_module, unused_module, unused_exposed, using_three_value, unused_with_alias]
import Dep1 import Dep1
import Dep3 exposing [Three] import Dep3 exposing [Three]
usedModule = used_module =
import Dep2 import Dep2
Dep2.two Dep2.two
unusedModule = unused_module =
import Dep2 import Dep2
2 2
unusedExposed = unused_exposed =
import Dep2 exposing [two] import Dep2 exposing [two]
2 2
usingThreeValue = using_three_value =
Dep3.three Dep3.three
unusedWithAlias = unused_with_alias =
import Dep2 as D2 import Dep2 as D2
2 2
"# "#
@ -1191,13 +1191,13 @@ fn explicit_builtin_type_import() {
r#" r#"
interface Main exposes [main] imports [] interface Main exposes [main] imports []
import Dict exposing [Dict, isEmpty] import Dict exposing [Dict, is_empty]
myDict : Dict * * my_dict : Dict * *
myDict = my_dict =
Dict.empty {} Dict.empty {}
main = isEmpty myDict main = is_empty my_dict
"# "#
), ),
)]; )];
@ -1210,7 +1210,7 @@ fn explicit_builtin_type_import() {
`Dict.Dict` was imported here: `Dict.Dict` was imported here:
3│ import Dict exposing [Dict, isEmpty] 3│ import Dict exposing [Dict, is_empty]
^^^^ ^^^^
All types from builtins are automatically exposed, so you can remove All types from builtins are automatically exposed, so you can remove
@ -1490,9 +1490,9 @@ fn alias_using_builtin_name() {
"BoolExtra.roc", "BoolExtra.roc",
indoc!( indoc!(
r" r"
interface BoolExtra exposes [toNum] imports [] interface BoolExtra exposes [to_num] imports []
toNum = \value -> to_num = \value ->
if value then 1 else 0 if value then 1 else 0
" "
), ),

552
crates/compiler/solve/tests/solve_expr.rs
View file

File diff suppressed because it is too large Load diff

8
crates/compiler/uitest/tests/ability/impl_ability_for_opaque_with_lambda_sets.txt
View file

@ -1,9 +1,9 @@
app "test" provides [isEqQ] to "./platform" app "test" provides [is_eq_q] to "./platform"
Q := [ F (Str -> Str), G ] implements [Eq { isEq: isEqQ }] Q := [ F (Str -> Str), G ] implements [Eq { is_eq: is_eq_q }]
isEqQ = \@Q q1, @Q q2 -> when T q1 q2 is is_eq_q = \@Q q1, @Q q2 -> when T q1 q2 is
#^^^^^{-1} Q, Q -[[isEqQ(0)]]-> Bool #^^^^^^^{-1} Q, Q -[[is_eq_q(0)]]-> Bool
T (F _) (F _) -> Bool.true T (F _) (F _) -> Bool.true
T G G -> Bool.true T G G -> Bool.true
_ -> Bool.false _ -> Bool.false

10
crates/compiler/uitest/tests/ability/impl_ability_for_opaque_with_lambda_sets_material.txt
View file

@ -1,10 +1,10 @@
# +opt infer:print_only_under_alias # +opt infer:print_only_under_alias
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
Q := ({} -> Str) implements [Eq {isEq: isEqQ}] Q := ({} -> Str) implements [Eq {is_eq: is_eq_q}]
isEqQ = \@Q f1, @Q f2 -> (f1 {} == f2 {}) is_eq_q = \@Q f1, @Q f2 -> (f1 {} == f2 {})
#^^^^^{-1} ({} -[[]]-> Str), ({} -[[]]-> Str) -[[isEqQ(2)]]-> [False, True] #^^^^^^^{-1} ({} -[[]]-> Str), ({} -[[]]-> Str) -[[is_eq_q(2)]]-> [False, True]
main = isEqQ (@Q \{} -> "a") (@Q \{} -> "a") main = is_eq_q (@Q \{} -> "a") (@Q \{} -> "a")
# ^^^^^ ({} -[[6, 7]]-> Str), ({} -[[6, 7]]-> Str) -[[isEqQ(2)]]-> [False, True] # ^^^^^^^ ({} -[[6, 7]]-> Str), ({} -[[6, 7]]-> Str) -[[is_eq_q(2)]]-> [False, True]

24
crates/compiler/uitest/tests/ability/smoke/decoder.txt
View file

@ -1,4 +1,4 @@
app "test" provides [myU8] to "./platform" app "test" provides [my_u8] to "./platform"
MDecodeError : [TooShort, Leftover (List U8)] MDecodeError : [TooShort, Leftover (List U8)]
@ -10,16 +10,16 @@ MDecoding implements
MDecoderFormatting implements MDecoderFormatting implements
u8 : MDecoder U8 fmt where fmt implements MDecoderFormatting u8 : MDecoder U8 fmt where fmt implements MDecoderFormatting
decodeWith : List U8, MDecoder val fmt, fmt -> { result: Result val MDecodeError, rest: List U8 } where fmt implements MDecoderFormatting decode_with : List U8, MDecoder val fmt, fmt -> { result: Result val MDecodeError, rest: List U8 } where fmt implements MDecoderFormatting
decodeWith = \lst, (@MDecoder doDecode), fmt -> doDecode lst fmt decode_with = \lst, (@MDecoder doDecode), fmt -> doDecode lst fmt
fromBytes : List U8, fmt -> Result val MDecodeError from_bytes : List U8, fmt -> Result val MDecodeError
where fmt implements MDecoderFormatting, val implements MDecoding where fmt implements MDecoderFormatting, val implements MDecoding
fromBytes = \lst, fmt -> from_bytes = \lst, fmt ->
when decodeWith lst decoder fmt is when decode_with lst decoder fmt is
{ result, rest } -> { result, rest } ->
when result is when result is
Ok val -> if List.isEmpty rest then Ok val else Err (Leftover rest) Ok val -> if List.is_empty rest then Ok val else Err (Leftover rest)
Err e -> Err e Err e -> Err e
@ -28,17 +28,17 @@ Linear := {} implements [MDecoderFormatting {u8}]
u8 = @MDecoder \lst, @Linear {} -> u8 = @MDecoder \lst, @Linear {} ->
#^^{-1} Linear#u8(11): MDecoder U8 Linear #^^{-1} Linear#u8(11): MDecoder U8 Linear
when List.first lst is when List.first lst is
Ok n -> { result: Ok n, rest: List.dropFirst lst 1 } Ok n -> { result: Ok n, rest: List.drop_first lst 1 }
Err _ -> { result: Err TooShort, rest: [] } Err _ -> { result: Err TooShort, rest: [] }
MyU8 := U8 implements [MDecoding {decoder}] MyU8 := U8 implements [MDecoding {decoder}]
decoder = @MDecoder \lst, fmt -> decoder = @MDecoder \lst, fmt ->
#^^^^^^^{-1} MyU8#decoder(12): MDecoder MyU8 fmt where fmt implements MDecoderFormatting #^^^^^^^{-1} MyU8#decoder(12): MDecoder MyU8 fmt where fmt implements MDecoderFormatting
when decodeWith lst u8 fmt is when decode_with lst u8 fmt is
{ result, rest } -> { result, rest } ->
{ result: Result.map result (\n -> @MyU8 n), rest } { result: Result.map result (\n -> @MyU8 n), rest }
myU8 : Result MyU8 _ my_u8 : Result MyU8 _
myU8 = fromBytes [15] (@Linear {}) my_u8 = from_bytes [15] (@Linear {})
#^^^^{-1} Result MyU8 MDecodeError #^^^^^{-1} Result MyU8 MDecodeError

22
crates/compiler/uitest/tests/ability/smoke/encoder.txt
View file

@ -1,18 +1,18 @@
app "test" provides [myU8Bytes] to "./platform" app "test" provides [my_u8_bytes] to "./platform"
MEncoder fmt := List U8, fmt -> List U8 where fmt implements Format MEncoder fmt := List U8, fmt -> List U8 where fmt implements Format
MEncoding implements MEncoding implements
toEncoder : val -> MEncoder fmt where val implements MEncoding, fmt implements Format to_encoder : val -> MEncoder fmt where val implements MEncoding, fmt implements Format
Format implements Format implements
u8 : U8 -> MEncoder fmt where fmt implements Format u8 : U8 -> MEncoder fmt where fmt implements Format
appendWith : List U8, MEncoder fmt, fmt -> List U8 where fmt implements Format append_with : List U8, MEncoder fmt, fmt -> List U8 where fmt implements Format
appendWith = \lst, (@MEncoder doFormat), fmt -> doFormat lst fmt append_with = \lst, (@MEncoder doFormat), fmt -> doFormat lst fmt
toBytes : val, fmt -> List U8 where val implements MEncoding, fmt implements Format to_bytes : val, fmt -> List U8 where val implements MEncoding, fmt implements Format
toBytes = \val, fmt -> appendWith [] (toEncoder val) fmt to_bytes = \val, fmt -> append_with [] (to_encoder val) fmt
Linear := {} implements [Format {u8}] Linear := {} implements [Format {u8}]
@ -20,10 +20,10 @@ Linear := {} implements [Format {u8}]
u8 = \n -> @MEncoder (\lst, @Linear {} -> List.append lst n) u8 = \n -> @MEncoder (\lst, @Linear {} -> List.append lst n)
#^^{-1} Linear#u8(10): U8 -[[u8(10)]]-> MEncoder Linear #^^{-1} Linear#u8(10): U8 -[[u8(10)]]-> MEncoder Linear
MyU8 := U8 implements [MEncoding {toEncoder}] MyU8 := U8 implements [MEncoding {to_encoder}]
toEncoder = \@MyU8 n -> u8 n to_encoder = \@MyU8 n -> u8 n
#^^^^^^^^^{-1} MyU8#toEncoder(11): MyU8 -[[toEncoder(11)]]-> MEncoder fmt where fmt implements Format #^^^^^^^^^^{-1} MyU8#to_encoder(11): MyU8 -[[to_encoder(11)]]-> MEncoder fmt where fmt implements Format
myU8Bytes = toBytes (@MyU8 15) (@Linear {}) my_u8_bytes = to_bytes (@MyU8 15) (@Linear {})
#^^^^^^^^^{-1} List U8 #^^^^^^^^^^^{-1} List U8

4
crates/compiler/uitest/tests/ability/specialize/bool_decoder.txt
View file

@ -2,5 +2,5 @@ app "test" provides [main] to "./platform"
main : Decoder Bool _ main : Decoder Bool _
main = Decode.custom \bytes, fmt -> main = Decode.custom \bytes, fmt ->
Decode.decodeWith bytes Decode.decoder fmt Decode.decode_with bytes Decode.decoder fmt
# ^^^^^^^^^^^^^^ Decoding#Decode.decoder(4): Decoder Bool fmt where fmt implements DecoderFormatting # ^^^^^^^^^^^^^^ Decoding#Decode.decoder(4): Decoder Bool fmt where fmt implements DecoderFormatting

4
crates/compiler/uitest/tests/ability/specialize/bool_eq.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Bool.isEq Bool.true Bool.false main = Bool.is_eq Bool.true Bool.false
# ^^^^^^^^^ Eq#Bool.isEq(9): Bool, Bool -[[Bool.structuralEq(11)]]-> Bool # ^^^^^^^^^^ Eq#Bool.is_eq(9): Bool, Bool -[[Bool.structural_eq(11)]]-> Bool

2
crates/compiler/uitest/tests/ability/specialize/bool_hash.txt
View file

@ -2,4 +2,4 @@ app "test" provides [main] to "./platform"
main = main =
\h -> Hash.hash h Bool.true \h -> Hash.hash h Bool.true
# ^^^^^^^^^ Hash#Hash.hash(1): a, Bool -[[Hash.hashBool(9)]]-> a where a implements Hasher # ^^^^^^^^^ Hash#Hash.hash(1): a, Bool -[[Hash.hash_bool(9)]]-> a where a implements Hasher

4
crates/compiler/uitest/tests/ability/specialize/bool_to_encoder.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Encode.toEncoder Bool.true main = Encode.to_encoder Bool.true
# ^^^^^^^^^^^^^^^^ Encoding#Encode.toEncoder(2): Bool -[[] + fmt:Encode.bool(17):1]-> Encoder fmt where fmt implements EncoderFormatting # ^^^^^^^^^^^^^^^^^ Encoding#Encode.to_encoder(2): Bool -[[] + fmt:Encode.bool(17):1]-> Encoder fmt where fmt implements EncoderFormatting

2
crates/compiler/uitest/tests/ability/specialize/dec_hash.txt
View file

@ -2,4 +2,4 @@ app "test" provides [main] to "./platform"
main = main =
\h -> Hash.hash h 1.1dec \h -> Hash.hash h 1.1dec
# ^^^^^^^^^ Hash#Hash.hash(1): a, Dec -[[Hash.hashDec(17)]]-> a where a implements Hasher # ^^^^^^^^^ Hash#Hash.hash(1): a, Dec -[[Hash.hash_dec(17)]]-> a where a implements Hasher

4
crates/compiler/uitest/tests/ability/specialize/inspect/bool.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Inspect.toInspector Bool.true |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector Bool.true |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): Bool -[[] + f:Inspect.bool(13):1]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): Bool -[[] + f:Inspect.bool(13):1]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/inspect/dec.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Inspect.toInspector 7dec |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector 7dec |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): Dec -[[] + f:Inspect.dec(29):1]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): Dec -[[] + f:Inspect.dec(29):1]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/inspect/non_implementing_opaque.txt
View file

@ -2,5 +2,5 @@ app "test" provides [main] to "./platform"
Op := {} Op := {}
main = Inspect.toInspector (@Op {}) |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector (@Op {}) |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): Op -[[] + f:Inspect.opaque(15):1]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): Op -[[] + f:Inspect.opaque(15):1]-> Inspector f where f implements InspectFormatter

50
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
View file

@ -8,42 +8,42 @@ main =
1 1
# -emit:mono # -emit:mono
procedure Inspect.252 (Inspect.253): procedure Inspect.251 (Inspect.252):
let Inspect.317 : Str = "<opaque>"; let Inspect.316 : Str = "<opaque>";
let Inspect.316 : Str = CallByName Inspect.63 Inspect.253 Inspect.317; let Inspect.315 : Str = CallByName Inspect.63 Inspect.252 Inspect.316;
dec Inspect.317; dec Inspect.316;
ret Inspect.316; ret Inspect.315;
procedure Inspect.30 (Inspect.147): procedure Inspect.30 (Inspect.147):
ret Inspect.147; ret Inspect.147;
procedure Inspect.33 (Inspect.152): procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152; let Inspect.304 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305; let Inspect.303 : Str = CallByName Inspect.64 Inspect.304;
ret Inspect.304; ret Inspect.303;
procedure Inspect.39 (Inspect.301): procedure Inspect.39 (Inspect.300):
let Inspect.311 : Str = ""; let Inspect.310 : Str = "";
ret Inspect.311; ret Inspect.310;
procedure Inspect.48 (Inspect.299): procedure Inspect.48 (Inspect.298):
let Inspect.314 : {} = Struct {}; let Inspect.313 : {} = Struct {};
let Inspect.313 : {} = CallByName Inspect.30 Inspect.314; let Inspect.312 : {} = CallByName Inspect.30 Inspect.313;
ret Inspect.313; ret Inspect.312;
procedure Inspect.5 (Inspect.150): procedure Inspect.5 (Inspect.150):
let Inspect.312 : {} = CallByName Inspect.48 Inspect.150; let Inspect.311 : {} = CallByName Inspect.48 Inspect.150;
let Inspect.309 : {} = Struct {}; let Inspect.308 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309; let Inspect.307 : Str = CallByName Inspect.39 Inspect.308;
let Inspect.307 : Str = CallByName Inspect.252 Inspect.308; let Inspect.306 : Str = CallByName Inspect.251 Inspect.307;
ret Inspect.307; ret Inspect.306;
procedure Inspect.63 (Inspect.300, Inspect.296): procedure Inspect.63 (Inspect.299, Inspect.295):
let Inspect.319 : Str = CallByName Str.3 Inspect.300 Inspect.296; let Inspect.318 : Str = CallByName Str.3 Inspect.299 Inspect.295;
ret Inspect.319; ret Inspect.318;
procedure Inspect.64 (Inspect.302): procedure Inspect.64 (Inspect.301):
ret Inspect.302; ret Inspect.301;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

50
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
View file

@ -11,42 +11,42 @@ main =
late (@Op {}) late (@Op {})
# -emit:mono # -emit:mono
procedure Inspect.252 (Inspect.253): procedure Inspect.251 (Inspect.252):
let Inspect.317 : Str = "<opaque>"; let Inspect.316 : Str = "<opaque>";
let Inspect.316 : Str = CallByName Inspect.63 Inspect.253 Inspect.317; let Inspect.315 : Str = CallByName Inspect.63 Inspect.252 Inspect.316;
dec Inspect.317; dec Inspect.316;
ret Inspect.316; ret Inspect.315;
procedure Inspect.30 (Inspect.147): procedure Inspect.30 (Inspect.147):
ret Inspect.147; ret Inspect.147;
procedure Inspect.33 (Inspect.152): procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152; let Inspect.304 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305; let Inspect.303 : Str = CallByName Inspect.64 Inspect.304;
ret Inspect.304; ret Inspect.303;
procedure Inspect.39 (Inspect.301): procedure Inspect.39 (Inspect.300):
let Inspect.311 : Str = ""; let Inspect.310 : Str = "";
ret Inspect.311; ret Inspect.310;
procedure Inspect.48 (Inspect.299): procedure Inspect.48 (Inspect.298):
let Inspect.314 : {} = Struct {}; let Inspect.313 : {} = Struct {};
let Inspect.313 : {} = CallByName Inspect.30 Inspect.314; let Inspect.312 : {} = CallByName Inspect.30 Inspect.313;
ret Inspect.313; ret Inspect.312;
procedure Inspect.5 (Inspect.150): procedure Inspect.5 (Inspect.150):
let Inspect.312 : {} = CallByName Inspect.48 Inspect.150; let Inspect.311 : {} = CallByName Inspect.48 Inspect.150;
let Inspect.309 : {} = Struct {}; let Inspect.308 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309; let Inspect.307 : Str = CallByName Inspect.39 Inspect.308;
let Inspect.307 : Str = CallByName Inspect.252 Inspect.308; let Inspect.306 : Str = CallByName Inspect.251 Inspect.307;
ret Inspect.307; ret Inspect.306;
procedure Inspect.63 (Inspect.300, Inspect.296): procedure Inspect.63 (Inspect.299, Inspect.295):
let Inspect.319 : Str = CallByName Str.3 Inspect.300 Inspect.296; let Inspect.318 : Str = CallByName Str.3 Inspect.299 Inspect.295;
ret Inspect.319; ret Inspect.318;
procedure Inspect.64 (Inspect.302): procedure Inspect.64 (Inspect.301):
ret Inspect.302; ret Inspect.301;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

6
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_custom_impl.txt
View file

@ -1,9 +1,9 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
Op := U8 implements [Inspect { toInspector: myToInspector }] Op := U8 implements [Inspect { to_inspector: myToInspector }]
myToInspector : Op -> Inspector f where f implements InspectFormatter myToInspector : Op -> Inspector f where f implements InspectFormatter
myToInspector = \@Op num -> Inspect.u8 num myToInspector = \@Op num -> Inspect.u8 num
main = Inspect.toInspector (@Op 1u8) |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector (@Op 1u8) |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Op#Inspect.toInspector(2): Op -[[myToInspector(2)]]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Op#Inspect.to_inspector(2): Op -[[myToInspector(2)]]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_derived.txt
View file

@ -2,5 +2,5 @@ app "test" provides [main] to "./platform"
Op := U8 implements [Inspect] Op := U8 implements [Inspect]
main = Inspect.toInspector (@Op 1u8) |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector (@Op 1u8) |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Op#Inspect.toInspector(3): Op -[[#Op_toInspector(3)]]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Op#Inspect.to_inspector(3): Op -[[#Op_to_inspector(3)]]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/inspect/ranged_num.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Inspect.toInspector 7 |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector 7 |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): I64 -[[] + f:Inspect.i64(24):1]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): I64 -[[] + f:Inspect.i64(24):1]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/inspect/record.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Inspect.toInspector { a: "" } |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector { a: "" } |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): { a : Str } -[[#Derived.toInspector_{a}(0)]]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): { a : Str } -[[#Derived.to_inspector_{a}(0)]]-> Inspector f where f implements InspectFormatter

6
crates/compiler/uitest/tests/ability/specialize/inspect/record_with_nested_custom_impl.txt
View file

@ -1,9 +1,9 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
Op := U8 implements [Inspect { toInspector: myToInspector }] Op := U8 implements [Inspect { to_inspector: myToInspector }]
myToInspector : Op -> Inspector f where f implements InspectFormatter myToInspector : Op -> Inspector f where f implements InspectFormatter
myToInspector = \@Op num -> Inspect.u8 num myToInspector = \@Op num -> Inspect.u8 num
main = Inspect.toInspector { op: @Op 1u8 } |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector { op: @Op 1u8 } |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): { op : Op } -[[#Derived.toInspector_{op}(0)]]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): { op : Op } -[[#Derived.to_inspector_{op}(0)]]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/inspect/u8.txt
View file

@ -1,4 +1,4 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
main = Inspect.toInspector 7u8 |> Inspect.apply (Inspect.init {}) main = Inspect.to_inspector 7u8 |> Inspect.apply (Inspect.init {})
# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): U8 -[[] + f:Inspect.u8(17):1]-> Inspector f where f implements InspectFormatter # ^^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.to_inspector(32): U8 -[[] + f:Inspect.u8(17):1]-> Inspector f where f implements InspectFormatter

4
crates/compiler/uitest/tests/ability/specialize/opaque_decoder_derive.txt
View file

@ -5,5 +5,5 @@ N := U8 implements [Decoding]
main : Decoder N _ main : Decoder N _
main = Decode.custom \bytes, fmt -> main = Decode.custom \bytes, fmt ->
Decode.decodeWith bytes Decode.decoder fmt Decode.decode_with bytes Decode.decoder fmt
# ^^^^^^^^^^^^^^ N#Decode.decoder(3): List U8, fmt -[[7]]-> { rest : List U8, result : [Err [TooShort], Ok U8] } where fmt implements DecoderFormatting # ^^^^^^^^^^^^^^ N#Decode.decoder(3): List U8, fmt -[[7]]-> { rest : List U8, result : [Err [TooShort], Ok U8] } where fmt implements DecoderFormatting

4
crates/compiler/uitest/tests/ability/specialize/opaque_encoder_derive.txt
View file

@ -2,5 +2,5 @@ app "test" provides [main] to "./platform"
N := U8 implements [Encoding] N := U8 implements [Encoding]
main = Encode.toEncoder (@N 15) main = Encode.to_encoder (@N 15)
# ^^^^^^^^^^^^^^^^ N#Encode.toEncoder(3): N -[[#N_toEncoder(3)]]-> Encoder fmt where fmt implements EncoderFormatting # ^^^^^^^^^^^^^^^^^ N#Encode.to_encoder(3): N -[[#N_to_encoder(3)]]-> Encoder fmt where fmt implements EncoderFormatting

8
crates/compiler/uitest/tests/ability/specialize/opaque_eq_custom.txt
View file

@ -1,8 +1,8 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
Trivial := {} implements [Eq {isEq}] Trivial := {} implements [Eq {is_eq}]
isEq = \@Trivial {}, @Trivial {} -> Bool.true is_eq = \@Trivial {}, @Trivial {} -> Bool.true
main = Bool.isEq (@Trivial {}) (@Trivial {}) main = Bool.is_eq (@Trivial {}) (@Trivial {})
# ^^^^^^^^^ Trivial#Bool.isEq(2): Trivial, Trivial -[[isEq(2)]]-> Bool # ^^^^^^^^^^ Trivial#Bool.is_eq(2): Trivial, Trivial -[[is_eq(2)]]-> Bool

4
crates/compiler/uitest/tests/ability/specialize/opaque_eq_derive.txt
View file

@ -2,5 +2,5 @@ app "test" provides [main] to "./platform"
N := U8 implements [Eq] N := U8 implements [Eq]
main = Bool.isEq (@N 15) (@N 23) main = Bool.is_eq (@N 15) (@N 23)
# ^^^^^^^^^ N#Bool.isEq(3): N, N -[[#N_isEq(3)]]-> Bool # ^^^^^^^^^^ N#Bool.is_eq(3): N, N -[[#N_is_eq(3)]]-> Bool

2
crates/compiler/uitest/tests/ability/specialize/ranged_num_hash.txt
View file

@ -2,4 +2,4 @@ app "test" provides [main] to "./platform"
main = main =
\h -> Hash.hash h 7 \h -> Hash.hash h 7
# ^^^^^^^^^ Hash#Hash.hash(1): a, I64 -[[Hash.hashI64(13)]]-> a where a implements Hasher # ^^^^^^^^^ Hash#Hash.hash(1): a, I64 -[[Hash.hash_i64(13)]]-> a where a implements Hasher

6
crates/compiler/uitest/tests/ability/specialize/record_to_encoder.txt
View file

@ -1,6 +1,6 @@
app "test" app "test"
imports [Encode.{ toEncoder }] imports [Encode.{ to_encoder }]
provides [main] to "./platform" provides [main] to "./platform"
main = toEncoder { a: "" } main = to_encoder { a: "" }
# ^^^^^^^^^ Encoding#toEncoder(2): { a : Str } -[[#Derived.toEncoder_{a}(0)]]-> Encoder fmt where fmt implements EncoderFormatting # ^^^^^^^^^^ Encoding#to_encoder(2): { a : Str } -[[#Derived.to_encoder_{a}(0)]]-> Encoder fmt where fmt implements EncoderFormatting

10
crates/compiler/uitest/tests/ability/specialize/record_to_encoder_with_nested_custom_impl.txt
View file

@ -1,9 +1,9 @@
app "test" app "test"
imports [Encode.{ toEncoder, custom }] imports [Encode.{ to_encoder, custom }]
provides [main] to "./platform" provides [main] to "./platform"
A := {} implements [Encoding {toEncoder}] A := {} implements [Encoding {to_encoder}]
toEncoder = \@A _ -> custom \b, _ -> b to_encoder = \@A _ -> custom \b, _ -> b
main = toEncoder { a: @A {} } main = to_encoder { a: @A {} }
# ^^^^^^^^^ Encoding#toEncoder(2): { a : A } -[[#Derived.toEncoder_{a}(0)]]-> Encoder fmt where fmt implements EncoderFormatting # ^^^^^^^^^^ Encoding#to_encoder(2): { a : A } -[[#Derived.to_encoder_{a}(0)]]-> Encoder fmt where fmt implements EncoderFormatting

6
crates/compiler/uitest/tests/ability/specialize/set_eq_issue_4761.txt
View file

@ -7,6 +7,6 @@ main =
s2 : Set Str s2 : Set Str
s2 = Set.empty {} s2 = Set.empty {}
Bool.isEq s1 s1 && Bool.isEq s2 s2 Bool.is_eq s1 s1 && Bool.is_eq s2 s2
# ^^^^^^^^^ Set#Bool.isEq(31): Set Str, Set Str -[[Set.isEq(31)]]-> Bool # ^^^^^^^^^^ Set#Bool.is_eq(31): Set Str, Set Str -[[Set.is_eq(31)]]-> Bool
# ^^^^^^^^^ Set#Bool.isEq(31): Set U8, Set U8 -[[Set.isEq(31)]]-> Bool # ^^^^^^^^^^ Set#Bool.is_eq(31): Set U8, Set U8 -[[Set.is_eq(31)]]-> Bool

2
crates/compiler/uitest/tests/lambda_set/disjoint_nested_lambdas_result_in_disjoint_parents_issue_4712.txt
View file

@ -42,4 +42,4 @@ parseInput = \{} ->
] is ] is
_ -> "" _ -> ""
main = Bool.isEq (parseInput {}) "" main = Bool.is_eq (parseInput {}) ""

2
crates/compiler/uitest/tests/recursion/choose_correct_recursion_var_under_record.txt
View file

@ -20,6 +20,6 @@ main =
printed = printCombinatorParser f.parser printed = printCombinatorParser f.parser
if Bool.false then printed else "foo" if Bool.false then printed else "foo"
|> List.first |> List.first
|> Result.withDefault ("foo") |> Result.with_default ("foo")
printCombinatorParser (Record []) printCombinatorParser (Record [])

2
crates/compiler/uitest/tests/solve/function_alias_in_signature.txt
View file

@ -5,7 +5,7 @@ Parser a : List U8 -> List [Pair a (List U8)]
any: Parser U8 any: Parser U8
any = \inp -> any = \inp ->
when List.first inp is when List.first inp is
Ok u -> [Pair u (List.dropFirst inp 1)] Ok u -> [Pair u (List.drop_first inp 1)]
_ -> [] _ -> []
main = any main = any

2
crates/compiler/uitest/tests/solve/issue_2583_specialize_errors_behind_unified_branches.txt
View file

@ -1,7 +1,7 @@
app "test" provides [main] to "./platform" app "test" provides [main] to "./platform"
entry = entry =
if Bool.true then List.first [] else Str.toI64 "" if Bool.true then List.first [] else Str.to_i64 ""
main = entry main = entry
# ^^^^^ Result I64 [InvalidNumStr, ListWasEmpty]w_a # ^^^^^ Result I64 [InvalidNumStr, ListWasEmpty]w_a

2
crates/compiler/uitest/tests/solve/multiple_abilities_multiple_members_specializations.txt
View file

@ -13,7 +13,7 @@ Id := U64 implements [MHash {hash, hash32}, Ord {eq, le}]
hash = \@Id n -> n hash = \@Id n -> n
#^^^^{-1} Id#hash(7): Id -[[hash(7)]]-> U64 #^^^^{-1} Id#hash(7): Id -[[hash(7)]]-> U64
hash32 = \@Id n -> Num.toU32 n hash32 = \@Id n -> Num.to_u32 n
#^^^^^^{-1} Id#hash32(8): Id -[[hash32(8)]]-> U32 #^^^^^^{-1} Id#hash32(8): Id -[[hash32(8)]]-> U32
eq = \@Id m, @Id n -> m == n eq = \@Id m, @Id n -> m == n

2
crates/compiler/uitest/tests/solve/single_ability_multiple_members_specializations.txt
View file

@ -9,5 +9,5 @@ Id := U64 implements [MHash {hash, hash32}]
hash = \@Id n -> n hash = \@Id n -> n
#^^^^{-1} Id#hash(4): Id -[[hash(4)]]-> U64 #^^^^{-1} Id#hash(4): Id -[[hash(4)]]-> U64
hash32 = \@Id n -> Num.toU32 n hash32 = \@Id n -> Num.to_u32 n
#^^^^^^{-1} Id#hash32(5): Id -[[hash32(5)]]-> U32 #^^^^^^{-1} Id#hash32(5): Id -[[hash32(5)]]-> U32

10
crates/compiler/uitest/tests/solve/stdlib_encode_something.txt
View file

@ -39,7 +39,7 @@ encodeF32 = \_n -> encodeNothing
encodeF64 = \_n -> encodeNothing encodeF64 = \_n -> encodeNothing
encodeDec = \_n -> encodeNothing encodeDec = \_n -> encodeNothing
encodeBool = \_b -> encodeNothing encodeBool = \_b -> encodeNothing
encodeString = \str -> Encode.custom \bytes, @OnlyStrEncoder {} -> List.concat bytes (Str.toUtf8 str) encodeString = \str -> Encode.custom \bytes, @OnlyStrEncoder {} -> List.concat bytes (Str.to_utf8 str)
encodeList : List elem, (elem -> Encoder OnlyStrEncoder) -> Encoder OnlyStrEncoder encodeList : List elem, (elem -> Encoder OnlyStrEncoder) -> Encoder OnlyStrEncoder
encodeList = \_lst, _encodeElem -> encodeNothing encodeList = \_lst, _encodeElem -> encodeNothing
encodeRecord : List {key: Str, value: Encoder OnlyStrEncoder} -> Encoder OnlyStrEncoder encodeRecord : List {key: Str, value: Encoder OnlyStrEncoder} -> Encoder OnlyStrEncoder
@ -50,15 +50,15 @@ encodeTag : Str, List (Encoder OnlyStrEncoder) -> Encoder OnlyStrEncoder
encodeTag = \_name, _payload -> encodeNothing encodeTag = \_name, _payload -> encodeNothing
HelloWorld := {} implements [Encoding {toEncoder}] HelloWorld := {} implements [Encoding {to_encoder}]
toEncoder = \@HelloWorld {} -> to_encoder = \@HelloWorld {} ->
Encode.custom \bytes, fmt -> Encode.custom \bytes, fmt ->
bytes bytes
|> Encode.appendWith (Encode.string "Hello, World!\n") fmt |> Encode.append_with (Encode.string "Hello, World!\n") fmt
f = f =
when Str.fromUtf8 (Encode.toBytes (@HelloWorld {}) (@OnlyStrEncoder {})) is when Str.from_utf8 (Encode.to_bytes (@HelloWorld {}) (@OnlyStrEncoder {})) is
Ok s -> s Ok s -> s
_ -> "<bad>" _ -> "<bad>"

6
crates/compiler/uitest/tests/solve/to_float.txt
View file

@ -2,9 +2,9 @@ app "test" provides [main] to "./platform"
entry = entry =
{ {
toF32: Num.toF32, to_f32: Num.to_f32,
toF64: Num.toF64, to_f64: Num.to_f64,
} }
main = entry main = entry
# ^^^^^ { toF32 : Num * -[[Num.toF32(139)]]-> F32, toF64 : Num w_a -[[Num.toF64(141)]]-> F64 } # ^^^^^ { to_f32 : Num * -[[Num.to_f32(139)]]-> F32, to_f64 : Num w_a -[[Num.to_f64(141)]]-> F64 }

22
crates/compiler/uitest/tests/solve/to_int.txt
View file

@ -2,17 +2,17 @@ app "test" provides [main] to "./platform"
entry = entry =
{ {
toI8: Num.toI8, to_i8: Num.to_i8,
toI16: Num.toI16, to_i16: Num.to_i16,
toI32: Num.toI32, to_i32: Num.to_i32,
toI64: Num.toI64, to_i64: Num.to_i64,
toI128: Num.toI128, to_i128: Num.to_i128,
toU8: Num.toU8, to_u8: Num.to_u8,
toU16: Num.toU16, to_u16: Num.to_u16,
toU32: Num.toU32, to_u32: Num.to_u32,
toU64: Num.toU64, to_u64: Num.to_u64,
toU128: Num.toU128, to_u128: Num.to_u128,
} }
main = entry main = entry
# ^^^^^ { toI128 : Int * -[[Num.toI128(125)]]-> I128, toI16 : Int w_a -[[Num.toI16(119)]]-> I16, toI32 : Int w_b -[[Num.toI32(121)]]-> I32, toI64 : Int w_c -[[Num.toI64(123)]]-> I64, toI8 : Int w_d -[[Num.toI8(117)]]-> I8, toU128 : Int w_e -[[Num.toU128(135)]]-> U128, toU16 : Int w_f -[[Num.toU16(129)]]-> U16, toU32 : Int w_g -[[Num.toU32(131)]]-> U32, toU64 : Int w_h -[[Num.toU64(133)]]-> U64, toU8 : Int w_i -[[Num.toU8(127)]]-> U8 } # ^^^^^ { to_i128 : Int * -[[Num.to_i128(125)]]-> I128, to_i16 : Int w_a -[[Num.to_i16(119)]]-> I16, to_i32 : Int w_b -[[Num.to_i32(121)]]-> I32, to_i64 : Int w_c -[[Num.to_i64(123)]]-> I64, to_i8 : Int w_d -[[Num.to_i8(117)]]-> I8, to_u128 : Int w_e -[[Num.to_u128(135)]]-> U128, to_u16 : Int w_f -[[Num.to_u16(129)]]-> U16, to_u32 : Int w_g -[[Num.to_u32(131)]]-> U32, to_u64 : Int w_h -[[Num.to_u64(133)]]-> U64, to_u8 : Int w_i -[[Num.to_u8(127)]]-> U8 }

4
crates/reporting/src/error/canonicalize.rs
View file

@ -1405,7 +1405,7 @@ pub fn can_problem<'b>(
)]), )]),
alloc.tip().append( alloc.tip().append(
alloc.reflow( alloc.reflow(
"An expression like `4`, `\"hello\"`, or `functionCall MyThing` is like `return 4` in other programming languages. To me, it seems like you did `return 4` followed by more code in the lines after, that code would never be executed!" "An expression like `4`, `\"hello\"`, or `function_call(MyThing)` is like `return 4` in other programming languages. To me, it seems like you did `return 4` followed by more code in the lines after, that code would never be executed!"
) )
), ),
alloc.tip().append( alloc.tip().append(
@ -1426,7 +1426,7 @@ pub fn can_problem<'b>(
alloc.region(lines.convert_region(region), severity), alloc.region(lines.convert_region(region), severity),
alloc.reflow("Add an exclamation mark at the end, like:"), alloc.reflow("Add an exclamation mark at the end, like:"),
alloc alloc
.parser_suggestion("{ readFile!: Str => Str }") .parser_suggestion("{ read_file!: Str => Str }")
.indent(4), .indent(4),
alloc.reflow("This will help readers identify it as a source of effects."), alloc.reflow("This will help readers identify it as a source of effects."),
]); ]);

2
crates/reporting/src/error/type.rs
View file

@ -436,7 +436,7 @@ pub fn type_problem<'b>(
alloc.region(lines.convert_region(region), severity), alloc.region(lines.convert_region(region), severity),
alloc.reflow("Add an exclamation mark at the end, like:"), alloc.reflow("Add an exclamation mark at the end, like:"),
alloc alloc
.parser_suggestion("{ readFile! : File.read! }") .parser_suggestion("{ read_file! : File.read! }")
.indent(4), .indent(4),
alloc.reflow("This will help readers identify it as a source of effects."), alloc.reflow("This will help readers identify it as a source of effects."),
]; ];