Format!

8 files changed, 81 insertions, 30 deletions

diff --git a/src/gleam/bytes_builder.gleam b/src/gleam/bytes_builder.gleam
index 20c145d..45f7cc9 100644
--- a/src/gleam/bytes_builder.gleam
+++ b/src/gleam/bytes_builder.gleam
@@ -37,7 +37,10 @@ pub fn new() -> BytesBuilder {
 ///
 /// Runs in constant time.
 ///
-pub fn prepend(to second: BytesBuilder, prefix first: BitArray) -> BytesBuilder {
+pub fn prepend(
+  to second: BytesBuilder,
+  prefix first: BitArray,
+) -> BytesBuilder {
   append_builder(from_bit_array(first), second)
 }
 
@@ -65,10 +68,7 @@ pub fn prepend_builder(
 /// Runs in constant time.
 ///
 @external(erlang, "gleam_stdlib", "iodata_append")
-pub fn append_builder(
-  to first: BytesBuilder,
-  suffix second: BytesBuilder,
-) -> BytesBuilder {
+pub fn append_builder(to first: BytesBuilder, suffix second: BytesBuilder) -> BytesBuilder {
   case second {
     Many(builders) -> Many([first, ..builders])
     _ -> Many([first, second])
diff --git a/src/gleam/dict.gleam b/src/gleam/dict.gleam
index afcd85a..c4a601f 100644
--- a/src/gleam/dict.gleam
+++ b/src/gleam/dict.gleam
@@ -151,7 +151,11 @@ fn do_get(a: Dict(key, value), b: key) -> Result(value, Nil)
 /// // -> from_list([#("a", 5)])
 /// ```
 ///
-pub fn insert(into dict: Dict(k, v), for key: k, insert value: v) -> Dict(k, v) {
+pub fn insert(
+  into dict: Dict(k, v),
+  for key: k,
+  insert value: v,
+) -> Dict(k, v) {
   do_insert(key, value, dict)
 }
 
@@ -273,10 +277,10 @@ pub fn filter(
 }
 
 @external(erlang, "maps", "filter")
-fn do_filter(
-  f: fn(key, value) -> Bool,
-  dict: Dict(key, value),
-) -> Dict(key, value) {
+fn do_filter(f: fn(key, value) -> Bool, dict: Dict(key, value)) -> Dict(
+  key,
+  value,
+) {
   let insert = fn(dict, k, v) {
     case f(k, v) {
       True -> insert(dict, k, v)
@@ -304,7 +308,10 @@ fn do_filter(
 /// // -> from_list([#("a", 0), #("b", 1)])
 /// ```
 ///
-pub fn take(from dict: Dict(k, v), keeping desired_keys: List(k)) -> Dict(k, v) {
+pub fn take(
+  from dict: Dict(k, v),
+  keeping desired_keys: List(k),
+) -> Dict(k, v) {
   do_take(desired_keys, dict)
 }
 
@@ -344,7 +351,10 @@ fn insert_taken(
 /// // -> from_list([#("a", 0), #("b", 2), #("c", 3)])
 /// ```
 ///
-pub fn merge(into dict: Dict(k, v), from new_entries: Dict(k, v)) -> Dict(k, v) {
+pub fn merge(
+  into dict: Dict(k, v),
+  from new_entries: Dict(k, v),
+) -> Dict(k, v) {
   do_merge(dict, new_entries)
 }
 
@@ -409,7 +419,10 @@ fn do_delete(a: k, b: Dict(k, v)) -> Dict(k, v)
 /// // -> from_list([])
 /// ```
 ///
-pub fn drop(from dict: Dict(k, v), drop disallowed_keys: List(k)) -> Dict(k, v) {
+pub fn drop(
+  from dict: Dict(k, v),
+  drop disallowed_keys: List(k),
+) -> Dict(k, v) {
   case disallowed_keys {
     [] -> dict
     [x, ..xs] -> drop(delete(dict, x), xs)
@@ -451,7 +464,11 @@ pub fn update(
   |> insert(dict, key, _)
 }
 
-fn do_fold(list: List(#(k, v)), initial: acc, fun: fn(acc, k, v) -> acc) -> acc {
+fn do_fold(
+  list: List(#(k, v)),
+  initial: acc,
+  fun: fn(acc, k, v) -> acc,
+) -> acc {
   case list {
     [] -> initial
     [#(k, v), ..rest] -> do_fold(rest, fun(initial, k, v), fun)
diff --git a/src/gleam/iterator.gleam b/src/gleam/iterator.gleam
index 27b856e..6be7c8d 100644
--- a/src/gleam/iterator.gleam
+++ b/src/gleam/iterator.gleam
@@ -448,7 +448,10 @@ fn do_append(first: fn() -> Action(a), second: fn() -> Action(a)) -> Action(a) {
 /// // -> [1, 2, 3, 4]
 /// ```
 ///
-pub fn append(to first: Iterator(a), suffix second: Iterator(a)) -> Iterator(a) {
+pub fn append(
+  to first: Iterator(a),
+  suffix second: Iterator(a),
+) -> Iterator(a) {
   fn() { do_append(first.continuation, second.continuation) }
   |> Iterator
 }
@@ -625,7 +628,10 @@ pub fn range(from start: Int, to stop: Int) -> Iterator(Int) {
   }
 }
 
-fn do_find(continuation: fn() -> Action(a), f: fn(a) -> Bool) -> Result(a, Nil) {
+fn do_find(
+  continuation: fn() -> Action(a),
+  f: fn(a) -> Bool,
+) -> Result(a, Nil) {
   case continuation() {
     Stop -> Error(Nil)
     Continue(e, next) ->
@@ -1141,7 +1147,9 @@ pub fn all(
   |> do_all(predicate)
 }
 
-fn update_group_with(el: element) -> fn(Option(List(element))) -> List(element) {
+fn update_group_with(
+  el: element,
+) -> fn(Option(List(element))) -> List(element) {
   fn(maybe_group) {
     case maybe_group {
       Some(group) -> [el, ..group]
diff --git a/src/gleam/list.gleam b/src/gleam/list.gleam
index 1ff2663..b59e5fd 100644
--- a/src/gleam/list.gleam
+++ b/src/gleam/list.gleam
@@ -398,7 +398,11 @@ pub fn map(list: List(a), with fun: fn(a) -> b) -> List(b) {
 /// // -> [#(1, "a"), #(2, "b")]
 /// ```
 /// 
-pub fn map2(list1: List(a), list2: List(b), with fun: fn(a, b) -> c) -> List(c) {
+pub fn map2(
+  list1: List(a),
+  list2: List(b),
+  with fun: fn(a, b) -> c,
+) -> List(c) {
   do_map2(list1, list2, fun, [])
 }
 
@@ -1250,8 +1254,7 @@ fn merge_sort(
         True ->
           merge_down(
             n,
-            ln
-            - n,
+            ln - n,
             merge_sort(a, n, compare, False),
             merge_sort(b, ln - n, compare, False),
             [],
@@ -1260,8 +1263,7 @@ fn merge_sort(
         False ->
           merge_up(
             n,
-            ln
-            - n,
+            ln - n,
             merge_sort(a, n, compare, True),
             merge_sort(b, ln - n, compare, True),
             [],
diff --git a/src/gleam/set.gleam b/src/gleam/set.gleam
index e8c88e7..00660a1 100644
--- a/src/gleam/set.gleam
+++ b/src/gleam/set.gleam
@@ -197,7 +197,10 @@ pub fn filter(
   Set(dict.filter(in: set.map, keeping: fn(m, _) { predicate(m) }))
 }
 
-pub fn drop(from set: Set(member), drop disallowed: List(member)) -> Set(member) {
+pub fn drop(
+  from set: Set(member),
+  drop disallowed: List(member),
+) -> Set(member) {
   list.fold(over: disallowed, from: set, with: delete)
 }
 
@@ -215,11 +218,17 @@ pub fn drop(from set: Set(member), drop disallowed: List(member)) -> Set(member)
 /// // -> [1, 3]
 /// ```
 ///
-pub fn take(from set: Set(member), keeping desired: List(member)) -> Set(member) {
+pub fn take(
+  from set: Set(member),
+  keeping desired: List(member),
+) -> Set(member) {
   Set(dict.take(from: set.map, keeping: desired))
 }
 
-fn order(first: Set(member), second: Set(member)) -> #(Set(member), Set(member)) {
+fn order(
+  first: Set(member),
+  second: Set(member),
+) -> #(Set(member), Set(member)) {
   case dict.size(first.map) > dict.size(second.map) {
     True -> #(first, second)
     False -> #(second, first)
diff --git a/src/gleam/string.gleam b/src/gleam/string.gleam
index e31c47d..0a165be 100644
--- a/src/gleam/string.gleam
+++ b/src/gleam/string.gleam
@@ -213,7 +213,11 @@ fn less_than(a: String, b: String) -> Bool
 /// // -> ""
 /// ```
 ///
-pub fn slice(from string: String, at_index idx: Int, length len: Int) -> String {
+pub fn slice(
+  from string: String,
+  at_index idx: Int,
+  length len: Int,
+) -> String {
   case len < 0 {
     True -> ""
     False ->
@@ -390,7 +394,10 @@ pub fn split_once(
 fn erl_split(a: String, b: String) -> List(String)
 
 @target(erlang)
-fn do_split_once(x: String, substring: String) -> Result(#(String, String), Nil) {
+fn do_split_once(
+  x: String,
+  substring: String,
+) -> Result(#(String, String), Nil) {
   case erl_split(x, substring) {
     [first, rest] -> Ok(#(first, rest))
     _ -> Error(Nil)
@@ -502,7 +509,11 @@ fn do_join(strings: List(String), separator: String) -> String {
 /// // -> "121"
 /// ```
 ///
-pub fn pad_left(string: String, to desired_length: Int, with pad_string: String) {
+pub fn pad_left(
+  string: String,
+  to desired_length: Int,
+  with pad_string: String,
+) {
   let current_length = length(string)
   let to_pad_length = desired_length - current_length
   padding(to_pad_length, pad_string)
diff --git a/src/gleam/string_builder.gleam b/src/gleam/string_builder.gleam
index 06916bc..cd2b247 100644
--- a/src/gleam/string_builder.gleam
+++ b/src/gleam/string_builder.gleam
@@ -38,7 +38,10 @@ pub fn prepend(
 ///
 /// Runs in constant time.
 ///
-pub fn append(to builder: StringBuilder, suffix second: String) -> StringBuilder {
+pub fn append(
+  to builder: StringBuilder,
+  suffix second: String,
+) -> StringBuilder {
   append_builder(builder, from_string(second))
 }
 
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
index f923365..bb3f502 100644
--- a/test/gleam/string_test.gleam
+++ b/test/gleam/string_test.gleam
@@ -965,7 +965,8 @@ pub fn target_inspect_test() {
 
   // Looks like: `//erl(#Ref<0.1809744150.4035444737.100468>)`.
   let assert Ok(regular_expression) =
-    regex.from_string("^\\/\\/erl\\(#Ref<[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+>\\)$",
+    regex.from_string(
+      "^\\/\\/erl\\(#Ref<[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+>\\)$",
     )
   string.inspect(create_erlang_reference())
   |> regex.check(regular_expression, _)