Formatting

Being picky :)

Author: lpil

src/list.gleam

@@ -164,8 +164,8 @@ pub fn all(list, f) {
     | [] -> True
     | [x | rest] ->
       case f(x) {
-        | True -> all(rest, f)
-        | _ -> False
+      | True -> all(rest, f)
+      | _ -> False
       }
   }
 }
@@ -175,8 +175,8 @@ pub fn any(list, f) {
     | [] -> False
     | [ x | rest] ->
       case f(x) {
-        | False -> any(rest, f)
-        | _ -> True
+      | False -> any(rest, f)
+      | _ -> True
       }
   }
 }
@@ -205,17 +205,17 @@ pub fn at(list, i) {
         | [] -> Error(NotFound)
         | [x | rest] ->
           case i == 0 {
-            | True -> Ok(x)
-            | False -> at(rest, i - 1)
+          | True -> Ok(x)
+          | False -> at(rest, i - 1)
           }
       }
   }
 }
 
 pub fn unique(list) {
   case list {
-    | [] -> []
-    | [x | rest] -> [x | unique(filter(rest, fn(y) { y != x }))]
+  | [] -> []
+  | [x | rest] -> [x | unique(filter(rest, fn(y) { y != x }))]
   }
 }
 
@@ -225,20 +225,20 @@ fn merge_sort(a, b) {
     | {_, []} -> a
     | {[ax | ar], [bx | br]} ->
       case ax < bx {
-        | True -> [ax | merge_sort(ar, b)]
-        | False -> [bx | merge_sort(a, br)]
+      | True -> [ax | merge_sort(ar, b)]
+      | False -> [bx | merge_sort(a, br)]
       }
   }
 }
 
 pub fn sort(list) {
   let list_length = length(list)
   case list_length < 2 {
-    | True -> list
-    | False ->
-      let split_length = list_length / 2
-      let a_list = take(list, split_length)
-      let b_list = drop(list, split_length)
-      merge_sort(sort(a_list), sort(b_list))
+  | True -> list
+  | False ->
+    let split_length = list_length / 2
+    let a_list = take(list, split_length)
+    let b_list = drop(list, split_length)
+    merge_sort(sort(a_list), sort(b_list))
   }
 }

test/list_test.gleam

@@ -165,98 +165,98 @@ pub fn find_test() {
 }
 
 pub fn all_test() {
-  list:all([1,2,3,4,5], fn(x) { x > 0 })
+  list:all([1, 2, 3, 4, 5], fn(x) { x > 0 })
   |> expect:equal(_, True)
 
-  list:all([1,2,3,4,5], fn(x) { x < 0 })
+  list:all([1, 2, 3, 4, 5], fn(x) { x < 0 })
   |> expect:equal(_, False)
 
   list:all([], fn(_) { False })
   |> expect:equal(_, True)
 }
 
 pub fn any_test() {
-  list:any([1,2,3,4,5], fn(x) { x == 2 })
+  list:any([1, 2, 3, 4, 5], fn(x) { x == 2 })
   |> expect:equal(_, True)
 
-  list:any([1,2,3,4,5], fn(x) { x < 0 })
+  list:any([1, 2, 3, 4, 5], fn(x) { x < 0 })
   |> expect:equal(_, False)
 
   list:any([], fn(_) { False })
   |> expect:equal(_, False)
 }
 
 pub fn zip_test() {
-  list:zip([], [1,2,3])
+  list:zip([], [1, 2, 3])
   |> expect:equal(_, [])
 
-  list:zip([1,2], [])
+  list:zip([1, 2], [])
   |> expect:equal(_, [])
 
-  list:zip([1,2,3], [4,5,6])
-  |> expect:equal(_, [{1,4}, {2,5}, {3,6}])
+  list:zip([1, 2, 3], [4, 5, 6])
+  |> expect:equal(_, [{1, 4}, {2, 5}, {3, 6}])
 
-  list:zip([5,6], [1,2,3])
-  |> expect:equal(_, [{5,1}, {6,2}])
+  list:zip([5, 6], [1, 2, 3])
+  |> expect:equal(_, [{5, 1}, {6, 2}])
 
-  list:zip([5,6,7], [1,2])
-  |> expect:equal(_, [{5,1}, {6,2}])
+  list:zip([5, 6, 7], [1, 2])
+  |> expect:equal(_, [{5, 1}, {6, 2}])
 }
 
 pub fn intersperse_test() {
-  list:intersperse([1,2,3], 4)
-  |> expect:equal(_, [1,4,2,4,3])
+  list:intersperse([1, 2, 3], 4)
+  |> expect:equal(_, [1, 4, 2, 4, 3])
 
   list:intersperse([], 2)
   |> expect:equal(_, [])
 }
 
 pub fn at_test() {
-  list:at([1,2,3], 2)
+  list:at([1, 2, 3], 2)
   |> expect:equal(_, Ok(3))
 
-  list:at([1,2,3], 5)
+  list:at([1, 2, 3], 5)
   |> expect:is_error
 
   list:at([], 0)
   |> expect:is_error
 
-  list:at([1,2,3,4,5,6], -1)
+  list:at([1, 2, 3, 4, 5, 6], -1)
   |> expect:is_error
 }
 
 pub fn unique_test() {
-  list:unique([1,1,2,3,4,4,4,5,6])
-  |> expect:equal(_, [1,2,3,4,5,6])
+  list:unique([1, 1, 2, 3, 4, 4, 4, 5, 6])
+  |> expect:equal(_, [1, 2, 3, 4, 5, 6])
 
-  list:unique([7,1,45,6,2,47,2,7,5])
-  |> expect:equal(_, [7,1,45,6,2,47,5])
+  list:unique([7, 1, 45, 6, 2, 47, 2, 7, 5])
+  |> expect:equal(_, [7, 1, 45, 6, 2, 47, 5])
 
-  list:unique([3,4,5])
-  |> expect:equal(_, [3,4,5])
+  list:unique([3, 4, 5])
+  |> expect:equal(_, [3, 4, 5])
 
   list:unique([])
   |> expect:equal(_, [])
 }
 
 pub fn sort_test() {
-  list:sort([4,3,6,5,4])
-  |> expect:equal(_, [3,4,4,5,6])
+  list:sort([4, 3, 6, 5, 4])
+  |> expect:equal(_, [3, 4, 4, 5, 6])
 
   list:sort([])
   |> expect:equal(_, [])
 
-  list:sort([{1,2}, {4,5}, {3,2}])
-  |> expect:equal(_, [{1,2}, {3,2}, {4,5}])
+  list:sort([{1, 2}, {4, 5}, {3, 2}])
+  |> expect:equal(_, [{1, 2}, {3, 2}, {4, 5}])
 }
 
 pub fn index_map_test() {
-  list:index_map([3,4,5], fn(i, x) { {i, x} })
-  |> expect:equal(_, [{0,3},{1,4},{2,5}])
+  list:index_map([3, 4, 5], fn(i, x) { {i, x} })
+  |> expect:equal(_, [{0, 3}, {1, 4}, {2, 5}])
 
   let f = fn(i, x) {
     str:append(x, str:from_int(i))
   }
-  list:index_map(["a","b","c"], f)
+  list:index_map(["a", "b", "c"], f)
   |> expect:equal(_, ["a0", "b1", "c2"])
 }