Fix some tests

roc-lang · Jan 11, 2025 · a1840b1 · a1840b1
1 parent ee3c71d
commit a1840b1
Show file tree

Hide file tree

Showing 6 changed files with 63 additions and 82 deletions.
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -39,7 +39,6 @@ ROC_TRACE_COMPACTION                   = "0"
 ROC_PRINT_UNIFICATIONS_DERIVED         = "0"
 ROC_PRINT_MISMATCHES                   = "0"
 ROC_PRINT_FIXPOINT_FIXING              = "0"
-ROC_VERIFY_RIGID_LET_GENERALIZED       = "0"
 ROC_VERIFY_OCCURS_ONE_RECURSION        = "0"
 ROC_CHECK_MONO_IR                      = "0"
 ROC_PRINT_IR_AFTER_SPECIALIZATION      = "0"

diff --git a/crates/cli/tests/benchmarks/AStar.roc b/crates/cli/tests/benchmarks/AStar.roc
@@ -3,7 +3,7 @@ module [find_path, Model, initial_model, cheapest_open, reconstruct_path]
 import Quicksort
 
 find_path = \cost_fn, move_fn, start, end ->
-    astar(cost_fn, move_fn, end, initial_model(start))
+    astar (cost_fn, move_fn, end, initial_model (start))
 
 Model position : {
     evaluated : Set position,
@@ -14,43 +14,43 @@ Model 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),
-    came_from: Dict.empty({}),
+    evaluated: Set.empty ({}),
+    open_set: Set.single (start),
+    costs: Dict.single (start, 0),
+    came_from: Dict.empty ({}),
 }
 
 cheapest_open : (position -> F64), Model position -> Result position {} where position implements Hash & Eq
 cheapest_open = \cost_fn, model ->
     model.open_set
     |> Set.to_list
-    |> List.keep_oks(
-        \position ->
-            when Dict.get(model.costs, position) is
-                Err(_) -> Err({})
-                Ok(cost) -> Ok({ cost: cost + cost_fn(position), position }),
-    )
-    |> Quicksort.sort_by(.cost)
+    |> List.keep_oks
+        (
+            \position ->
+                when Dict.get (model.costs, position) is
+                    Err _ -> Err ({})
+                    Ok cost -> Ok ({ cost: cost + cost_fn (position), position }))
+    |> Quicksort.sort_by (.cost)
     |> List.first
-    |> Result.map(.position)
-    |> Result.map_err(\_ -> {})
+    |> Result.map (.position)
+    |> Result.map_err (\_ -> {})
 
 reconstruct_path : Dict position position, position -> List position where position implements Hash & Eq
 reconstruct_path = \came_from, goal ->
-    when Dict.get(came_from, goal) is
-        Err(_) -> []
-        Ok(next) -> List.append(reconstruct_path(came_from, next), goal)
+    when Dict.get (came_from, goal) is
+        Err _ -> []
+        Ok next -> List.append (reconstruct_path (came_from, next), goal)
 
 update_cost : position, position, Model position -> Model position where position implements Hash & Eq
 update_cost = \current, neighbor, model ->
     new_came_from =
-        Dict.insert(model.came_from, neighbor, current)
+        Dict.insert (model.came_from, neighbor, current)
 
     new_costs =
-        Dict.insert(model.costs, neighbor, distance_to)
+        Dict.insert (model.costs, neighbor, distance_to)
 
     distance_to =
-        reconstruct_path(new_came_from, neighbor)
+        reconstruct_path (new_came_from, neighbor)
         |> List.len
         |> Num.to_frac
 
@@ -60,48 +60,48 @@ update_cost = \current, neighbor, model ->
             came_from: new_came_from,
         }
 
-    when Dict.get(model.costs, neighbor) is
-        Err(_) ->
+    when Dict.get (model.costs, neighbor) is
+        Err _ ->
             new_model
 
-        Ok(previous_distance) ->
+        Ok previous_distance ->
             if distance_to < previous_distance then
                 new_model
             else
                 model
 
 astar : (position, position -> F64), (position -> Set position), position, Model position -> Result (List position) {} where position implements Hash & Eq
 astar = \cost_fn, move_fn, goal, model ->
-    when cheapest_open(\source -> cost_fn(source, goal), model) is
-        Err({}) -> Err({})
-        Ok(current) ->
+    when cheapest_open (\source -> cost_fn (source, goal), model) is
+        Err {} -> Err ({})
+        Ok current ->
             if current == goal then
-                Ok(reconstruct_path(model.came_from, goal))
+                Ok (reconstruct_path (model.came_from, goal))
             else
                 model_popped =
                     { model &
-                        open_set: Set.remove(model.open_set, current),
-                        evaluated: Set.insert(model.evaluated, current),
+                        open_set: Set.remove (model.open_set, current),
+                        evaluated: Set.insert (model.evaluated, current),
                     }
 
                 neighbors =
-                    move_fn(current)
+                    move_fn (current)
 
                 new_neighbors =
-                    Set.difference(neighbors, model_popped.evaluated)
+                    Set.difference (neighbors, model_popped.evaluated)
 
-                model_with_neighbors : Model position
+                model_with_neighbors : Model _
                 model_with_neighbors =
                     model_popped
-                    |> &open_set(Set.union(model_popped.open_set, new_neighbors))
+                    |> &open_set (Set.union (model_popped.open_set, new_neighbors))
 
-                walker : Model position, position -> Model position
-                walker = \amodel, n -> update_cost(current, n, amodel)
+                walker : Model _, _ -> Model _
+                walker = \amodel, n -> update_cost (current, n, amodel)
 
                 model_with_costs =
-                    Set.walk(new_neighbors, model_with_neighbors, walker)
+                    Set.walk (new_neighbors, model_with_neighbors, walker)
 
-                astar(cost_fn, move_fn, goal, model_with_costs)
+                astar (cost_fn, move_fn, goal, model_with_costs)
 
 # takeStep = \moveFn, _goal, model, current ->
 #     modelPopped =

diff --git a/crates/compiler/solve/tests/solve_expr.rs b/crates/compiler/solve/tests/solve_expr.rs
@@ -2510,13 +2510,15 @@ mod solve_expr {
         infer_eq_without_problem(
             indoc!(
                 r"
-                    empty : [Cons a (ConsList a), Nil] as ConsList a
-                    empty = Nil
+                ConsList a : [Cons a (ConsList a), Nil]
 
-                    empty
-                       "
+                empty : ConsList _
+                empty = Nil
+
+                empty
+                   "
             ),
-            "ConsList a",
+            "ConsList *",
         );
     }
 
@@ -3742,7 +3744,7 @@ mod solve_expr {
             indoc!(
                 r"
                 \rec ->
-                    { x, y } : { x : I64, y ? Bool }*
+                    { x, y } : { x : I64, y ? Bool }_
                     { x, y ? Bool.false } = rec
 
                     { x, y }
@@ -3909,26 +3911,6 @@ mod solve_expr {
         );
     }
 
-    #[test]
-    fn double_named_rigids() {
-        infer_eq_without_problem(
-            indoc!(
-                r#"
-                app "test" provides [main] to "./platform"
-
-
-                main : List x
-                main =
-                    empty : List x
-                    empty = []
-
-                    empty
-                "#
-            ),
-            "List x",
-        );
-    }
-
     #[test]
     fn double_tag_application() {
         infer_eq_without_problem(

diff --git a/crates/compiler/test_gen/src/gen_primitives.rs b/crates/compiler/test_gen/src/gen_primitives.rs
@@ -662,7 +662,7 @@ fn linked_list_len_1() {
 
             LinkedList a : [Nil, Cons a (LinkedList a)]
 
-            one : LinkedList (Int *)
+            one : LinkedList (Int _)
             one = Cons 1 Nil
 
             length : LinkedList a -> Int *
@@ -690,7 +690,7 @@ fn linked_list_len_twice_1() {
 
             LinkedList a : [Nil, Cons a (LinkedList a)]
 
-            one : LinkedList (Int *)
+            one : LinkedList (Int _)
             one = Cons 1 Nil
 
             length : LinkedList a -> Int *
@@ -718,7 +718,7 @@ fn linked_list_len_3() {
 
             LinkedList a : [Nil, Cons a (LinkedList a)]
 
-            three : LinkedList (Int *)
+            three : LinkedList (Int _)
             three = Cons 3 (Cons 2 (Cons 1 Nil))
 
             length : LinkedList a -> Int *
@@ -747,7 +747,7 @@ fn linked_list_sum_num_a() {
 
             LinkedList a : [Nil, Cons a (LinkedList a)]
 
-            three : LinkedList (Int *)
+            three : LinkedList (Int _)
             three = Cons 3 (Cons 2 (Cons 1 Nil))
 
 
@@ -776,7 +776,7 @@ fn linked_list_sum_int() {
 
             LinkedList a : [Nil, Cons a (LinkedList a)]
 
-            zero : LinkedList (Int *)
+            zero : LinkedList (Int _)
             zero = Nil
 
             sum : LinkedList (Int a) -> Int a
@@ -804,7 +804,7 @@ fn linked_list_map() {
 
             LinkedList a : [Nil, Cons a (LinkedList a)]
 
-            three : LinkedList (Int *)
+            three : LinkedList (Int _)
             three = Cons 3 (Cons 2 (Cons 1 Nil))
 
             sum : LinkedList (Num a) -> Num a
@@ -836,7 +836,7 @@ fn when_nested_maybe() {
             r"
             Maybe a : [Nothing, Just a]
 
-            x : Maybe (Maybe (Int a))
+            x : Maybe (Maybe (Int _))
             x = Just (Just 41)
 
             when x is
@@ -853,7 +853,7 @@ fn when_nested_maybe() {
             r"
             Maybe a : [Nothing, Just a]
 
-            x : Maybe (Maybe (Int *))
+            x : Maybe (Maybe (Int _))
             x = Just Nothing
 
             when x is
@@ -871,7 +871,7 @@ fn when_nested_maybe() {
             r"
             Maybe a : [Nothing, Just a]
 
-            x : Maybe (Maybe (Int *))
+            x : Maybe (Maybe (Int _))
             x = Nothing
 
             when x is
@@ -1402,7 +1402,7 @@ fn recursive_function_with_rigid() {
                 else
                     1 + foo { count: state.count - 1, x: state.x }
 
-            main : Int *
+            main : Int _
             main =
                 foo { count: 3, x: {} }
             "#
@@ -1517,7 +1517,7 @@ fn rbtree_balance_3() {
             balance = \key, left ->
                 Node key left Empty
 
-            main : RedBlackTree (Int *)
+            main : RedBlackTree (Int _)
             main =
                 balance 0 Empty
             "#
@@ -1696,7 +1696,7 @@ fn nested_pattern_match_two_ways() {
                         _ -> 3
                 _ -> 3
 
-            main : Int *
+            main : Int _
             main =
                 when balance Nil is
                     _ -> 3
@@ -1719,7 +1719,7 @@ fn nested_pattern_match_two_ways() {
                 Cons 1 (Cons 1 _) -> 3
                 _ -> 3
 
-            main : Int *
+            main : Int _
             main =
                 when balance Nil is
                     _ -> 3
@@ -1751,7 +1751,7 @@ fn linked_list_guarded_double_pattern_match() {
                         _ -> 3
                 _ -> 3
 
-            main : Int *
+            main : Int _
             main =
                 when balance Nil is
                     _ -> 3
@@ -1778,7 +1778,7 @@ fn linked_list_double_pattern_match() {
                     Cons _ (Cons x _) -> x
                     _ -> 0
 
-            main : Int *
+            main : Int _
             main =
                 foo (Cons 1 (Cons 32 Nil))
             "#
@@ -1886,7 +1886,7 @@ fn wildcard_rigid() {
                 @Effect inner
 
 
-            main : MyTask {} (Frac *)
+            main : MyTask {} (Frac _)
             main = always {}
             "#
         ),

diff --git a/crates/compiler/test_gen/src/gen_result.rs b/crates/compiler/test_gen/src/gen_result.rs
@@ -135,7 +135,7 @@ fn err_type_var_annotation() {
     assert_evals_to!(
         indoc!(
             r"
-            ok : Result I64 *
+            ok : Result I64 _
             ok = Ok 3
 
             Result.map ok (\x -> x + 1)

diff --git a/crates/compiler/test_gen/src/gen_tags.rs b/crates/compiler/test_gen/src/gen_tags.rs
@@ -1075,7 +1075,7 @@ fn applied_tag_function_result() {
     assert_evals_to!(
         indoc!(
             r#"
-            x : List (Result Str *)
+            x : List (Result Str _)
             x = List.map ["a", "b"] Ok
 
             List.keep_oks x (\y -> y)