Run formatter

17 files changed, 199 insertions, 199 deletions

diff --git a/src/gleam/bit_builder.gleam b/src/gleam/bit_builder.gleam
index bcc4c4c..165099f 100644
--- a/src/gleam/bit_builder.gleam
+++ b/src/gleam/bit_builder.gleam
@@ -42,10 +42,7 @@ pub external fn prepend_builder(
 ///
 /// Runs in constant time.
 ///
-pub external fn append_builder(
-  to: BitBuilder,
-  suffix: BitBuilder,
-) -> BitBuilder =
+pub external fn append_builder(to: BitBuilder, suffix: BitBuilder) -> BitBuilder =
   "gleam_stdlib" "iodata_append"
 
 /// Prepend a string onto the start of a builder.
diff --git a/src/gleam/dynamic.gleam b/src/gleam/dynamic.gleam
index efd8dd5..bf7963f 100644
--- a/src/gleam/dynamic.gleam
+++ b/src/gleam/dynamic.gleam
@@ -54,14 +54,12 @@ pub external fn bit_string(from: Dynamic) -> Result(BitString, String) =
 ///
 pub fn string(from: Dynamic) -> Result(String, String) {
   bit_string(from)
-  |> result.then(
-    fn(raw) {
-      case bit_string_mod.to_string(raw) {
-        Ok(string) -> Ok(string)
-        Error(Nil) -> Error("Expected a string, got a bit_string")
-      }
-    },
-  )
+  |> result.then(fn(raw) {
+    case bit_string_mod.to_string(raw) {
+      Ok(string) -> Ok(string)
+      Error(Nil) -> Error("Expected a string, got a bit_string")
+    }
+  })
 }
 
 /// Check to see whether a Dynamic value is an int, and return the int if it
@@ -215,10 +213,7 @@ pub external fn field(from: Dynamic, named: a) -> Result(Dynamic, String) =
 ///    > element(from(""), 2)
 ///    Error("Expected a tuple, got a binary")
 ///
-pub external fn element(
-  from: Dynamic,
-  position: Int,
-) -> Result(Dynamic, String) =
+pub external fn element(from: Dynamic, position: Int) -> Result(Dynamic, String) =
   "gleam_stdlib" "decode_element"
 
 /// Check to see if the Dynamic value is a 2 element tuple.
@@ -237,9 +232,7 @@ pub external fn element(
 ///    > tuple2(from(""))
 ///    Error("Expected a tuple, got a binary")
 ///
-pub external fn tuple2(
-  from: Dynamic,
-) -> Result(tuple(Dynamic, Dynamic), String) =
+pub external fn tuple2(from: Dynamic) -> Result(tuple(Dynamic, Dynamic), String) =
   "gleam_stdlib" "decode_tuple2"
 
 /// Check to see if the Dynamic value is a 2 element tuple containing two
diff --git a/src/gleam/float.gleam b/src/gleam/float.gleam
index 254e5f0..ecb203c 100644
--- a/src/gleam/float.gleam
+++ b/src/gleam/float.gleam
@@ -38,10 +38,11 @@ pub fn to_string(f: Float) -> String {
 pub fn compare(a: Float, with b: Float) -> Order {
   case a == b {
     True -> order.Eq
-    False -> case a <. b {
-      True -> order.Lt
-      False -> order.Gt
-    }
+    False ->
+      case a <. b {
+        True -> order.Lt
+        False -> order.Gt
+      }
   }
 }
 
diff --git a/src/gleam/int.gleam b/src/gleam/int.gleam
index 1e9f17c..151bfa3 100644
--- a/src/gleam/int.gleam
+++ b/src/gleam/int.gleam
@@ -58,10 +58,11 @@ pub external fn to_base_string(Int, Int) -> String =
 pub fn compare(a: Int, with b: Int) -> Order {
   case a == b {
     True -> order.Eq
-    False -> case a < b {
-      True -> order.Lt
-      False -> order.Gt
-    }
+    False ->
+      case a < b {
+        True -> order.Lt
+        False -> order.Gt
+      }
   }
 }
 
diff --git a/src/gleam/iterator.gleam b/src/gleam/iterator.gleam
index 2365317..8cb01c1 100644
--- a/src/gleam/iterator.gleam
+++ b/src/gleam/iterator.gleam
@@ -174,15 +174,16 @@ fn do_take(
   acc: List(e),
 ) -> List(e) {
   case desired > 0 {
-    True -> case continuation() {
-      Continue(
-        element,
-        iterator,
-      ) -> do_take(iterator, desired - 1, [element, ..acc])
-      Stop -> acc
-        |> list.reverse
-    }
-    False -> acc
+    True ->
+      case continuation() {
+        Continue(element, iterator) ->
+          do_take(iterator, desired - 1, [element, ..acc])
+        Stop ->
+          acc
+          |> list.reverse
+      }
+    False ->
+      acc
       |> list.reverse
   }
 }
@@ -207,10 +208,11 @@ pub fn take(from iterator: Iterator(e), up_to desired: Int) -> List(e) {
 
 fn do_drop(continuation: fn() -> Action(e), desired: Int) -> fn() -> Action(e) {
   case desired > 0 {
-    True -> case continuation() {
-      Continue(_, iterator) -> do_drop(iterator, desired - 1)
-      Stop -> fn() { Stop }
-    }
+    True ->
+      case continuation() {
+        Continue(_, iterator) -> do_drop(iterator, desired - 1)
+        Stop -> fn() { Stop }
+      }
     False -> continuation
   }
 }
@@ -272,10 +274,11 @@ fn do_filter(
 ) -> fn() -> Action(e) {
   fn() {
     case continuation() {
-      Continue(e, iterator) -> case predicate(e) {
-        True -> Continue(e, do_filter(iterator, predicate))
-        False -> do_filter(iterator, predicate)()
-      }
+      Continue(e, iterator) ->
+        case predicate(e) {
+          True -> Continue(e, do_filter(iterator, predicate))
+          False -> do_filter(iterator, predicate)()
+        }
       Stop -> Stop
     }
   }
diff --git a/src/gleam/queue.gleam b/src/gleam/queue.gleam
index 5e67d50..1df8d12 100644
--- a/src/gleam/queue.gleam
+++ b/src/gleam/queue.gleam
@@ -210,10 +210,11 @@ fn check_equal(
 ) -> Bool {
   case xs, x_tail, ys, y_tail {
     [], [], [], [] -> True
-    [x, ..xs], _, [y, ..ys], _ -> case eq(x, y) {
-      False -> False
-      True -> check_equal(xs, x_tail, ys, y_tail, eq)
-    }
+    [x, ..xs], _, [y, ..ys], _ ->
+      case eq(x, y) {
+        False -> False
+        True -> check_equal(xs, x_tail, ys, y_tail, eq)
+      }
     [], [_, ..], _, _ -> check_equal(list.reverse(x_tail), [], ys, y_tail, eq)
     _, _, [], [_, ..] -> check_equal(xs, x_tail, list.reverse(y_tail), [], eq)
     _, _, _, _ -> False
diff --git a/src/gleam/set.gleam b/src/gleam/set.gleam
index a023bae..0455081 100644
--- a/src/gleam/set.gleam
+++ b/src/gleam/set.gleam
@@ -104,11 +104,12 @@ pub fn to_list(set: Set(member)) -> List(member) {
 ///    [1, 3, 3, 4]
 ///
 pub fn from_list(members: List(member)) -> Set(member) {
-  let map = list.fold(
-    over: members,
-    from: map.new(),
-    with: fn(k, m) { map.insert(m, k, []) },
-  )
+  let map =
+    list.fold(
+      over: members,
+      from: map.new(),
+      with: fn(k, m) { map.insert(m, k, []) },
+    )
   Set(map)
 }
 
@@ -163,10 +164,7 @@ pub fn filter(
 ///    > from_list([1, 2, 3]) |> take([1, 3, 5]) |> to_list
 ///    [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(map.take(from: set.map, keeping: desired))
 }
 
diff --git a/src/gleam/string.gleam b/src/gleam/string.gleam
index 26bf01d..941cd0c 100644
--- a/src/gleam/string.gleam
+++ b/src/gleam/string.gleam
@@ -150,23 +150,20 @@ external fn erl_slice(String, Int, Int) -> String =
 ///    > slice(from: "gleam", at_index: -12, length: 2)
 ///    ""
 ///
-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 -> case idx < 0 {
-      True -> {
-        let translated_idx = length(string) + idx
-        case translated_idx < 0 {
-          True -> ""
-          False -> erl_slice(string, translated_idx, len)
+    False ->
+      case idx < 0 {
+        True -> {
+          let translated_idx = length(string) + idx
+          case translated_idx < 0 {
+            True -> ""
+            False -> erl_slice(string, translated_idx, len)
+          }
         }
+        False -> erl_slice(string, idx, len)
       }
-      False -> erl_slice(string, idx, len)
-    }
   }
 }
 
diff --git a/src/gleam/uri.gleam b/src/gleam/uri.gleam
index b900f2c..32910b5 100644
--- a/src/gleam/uri.gleam
+++ b/src/gleam/uri.gleam
@@ -49,7 +49,8 @@ type UriKey {
 /// The opposite operation is `uri.to_string`
 ///
 pub fn parse(string: String) -> Result(Uri, Nil) {
-  try uri_map = dynamic.map(erl_parse(string))
+  try uri_map =
+    dynamic.map(erl_parse(string))
     |> result.nil_error
   let get = fn(k: UriKey, decode_type: dynamic.Decoder(t)) -> Option(t) {
     uri_map
@@ -58,15 +59,16 @@ pub fn parse(string: String) -> Result(Uri, Nil) {
     |> option.from_result
   }
 
-  let uri = Uri(
-    scheme: get(Scheme, dynamic.string),
-    userinfo: get(Userinfo, dynamic.string),
-    host: get(Host, dynamic.string),
-    port: get(Port, dynamic.int),
-    path: option.unwrap(get(Path, dynamic.string), ""),
-    query: get(Query, dynamic.string),
-    fragment: get(Fragment, dynamic.string),
-  )
+  let uri =
+    Uri(
+      scheme: get(Scheme, dynamic.string),
+      userinfo: get(Userinfo, dynamic.string),
+      host: get(Host, dynamic.string),
+      port: get(Port, dynamic.int),
+      path: option.unwrap(get(Path, dynamic.string), ""),
+      query: get(Query, dynamic.string),
+      fragment: get(Fragment, dynamic.string),
+    )
   Ok(uri)
 }
 
@@ -157,10 +159,10 @@ external fn erl_to_string(Map(UriKey, Dynamic)) -> Dynamic =
 /// The opposite operation is `uri.parse`.
 ///
 pub fn to_string(uri: Uri) -> String {
-  let field = fn(
-    key: UriKey,
-    value: Option(anything),
-  ) -> Result(tuple(UriKey, Dynamic), Nil) {
+  let field = fn(key: UriKey, value: Option(anything)) -> Result(
+    tuple(UriKey, Dynamic),
+    Nil,
+  ) {
     case value {
       Some(v) -> Ok(tuple(key, dynamic.from(v)))
       None -> Error(Nil)
@@ -215,50 +217,56 @@ fn join_segments(segments: List(String)) -> String {
 /// The algorithm for merging uris is described in [RFC 3986](https://tools.ietf.org/html/rfc3986#section-5.2)
 pub fn merge(base: Uri, relative: Uri) -> Result(Uri, Nil) {
   case base {
-    Uri(scheme: Some(_), host: Some(_), ..) -> case relative {
-      Uri(host: Some(_), ..) -> {
-        let path = string.split(relative.path, "/")
-          |> remove_dot_segments()
-          |> join_segments()
-        let resolved = Uri(
-          option.or(relative.scheme, base.scheme),
-          None,
-          relative.host,
-          relative.port,
-          path,
-          relative.query,
-          relative.fragment,
-        )
-        Ok(resolved)
-      }
-      Uri(scheme: None, host: None, ..) -> {
-        let tuple(new_path, new_query) = case relative.path {
-          "" -> tuple(base.path, option.or(relative.query, base.query))
-          _ -> {
-            let path_segments = case string.starts_with(relative.path, "/") {
-              True -> string.split(relative.path, "/")
-              False -> string.split(base.path, "/")
-                |> drop_last()
-                |> list.append(string.split(relative.path, "/"))
+    Uri(scheme: Some(_), host: Some(_), ..) ->
+      case relative {
+        Uri(host: Some(_), ..) -> {
+          let path =
+            string.split(relative.path, "/")
+            |> remove_dot_segments()
+            |> join_segments()
+          let resolved =
+            Uri(
+              option.or(relative.scheme, base.scheme),
+              None,
+              relative.host,
+              relative.port,
+              path,
+              relative.query,
+              relative.fragment,
+            )
+          Ok(resolved)
+        }
+        Uri(scheme: None, host: None, ..) -> {
+          let tuple(new_path, new_query) = case relative.path {
+            "" -> tuple(base.path, option.or(relative.query, base.query))
+            _ -> {
+              let path_segments = case string.starts_with(relative.path, "/") {
+                True -> string.split(relative.path, "/")
+                False ->
+                  string.split(base.path, "/")
+                  |> drop_last()
+                  |> list.append(string.split(relative.path, "/"))
+              }
+              let path =
+                path_segments
+                |> remove_dot_segments()
+                |> join_segments()
+              tuple(path, relative.query)
             }
-            let path = path_segments
-              |> remove_dot_segments()
-              |> join_segments()
-            tuple(path, relative.query)
           }
+          let resolved =
+            Uri(
+              base.scheme,
+              None,
+              base.host,
+              base.port,
+              new_path,
+              new_query,
+              relative.fragment,
+            )
+          Ok(resolved)
         }
-        let resolved = Uri(
-          base.scheme,
-          None,
-          base.host,
-          base.port,
-          new_path,
-          new_query,
-          relative.fragment,
-        )
-        Ok(resolved)
       }
-    }
     _ -> Error(Nil)
   }
 }
diff --git a/test/gleam/atom_test.gleam b/test/gleam/atom_test.gleam
index 29a5b41..4617489 100644
--- a/test/gleam/atom_test.gleam
+++ b/test/gleam/atom_test.gleam
@@ -29,9 +29,9 @@ pub fn create_from_string_test() {
   "this is another atom we have not seen before"
   |> atom.create_from_string
   |> Ok
-  |> should.equal(
-    atom.from_string("this is another atom we have not seen before"),
-  )
+  |> should.equal(atom.from_string(
+    "this is another atom we have not seen before",
+  ))
 }
 
 pub fn to_string_test() {
diff --git a/test/gleam/bit_builder_test.gleam b/test/gleam/bit_builder_test.gleam
index 48ea555..e1ec57b 100644
--- a/test/gleam/bit_builder_test.gleam
+++ b/test/gleam/bit_builder_test.gleam
@@ -2,7 +2,8 @@ import gleam/should
 import gleam/bit_builder
 
 pub fn builder_test() {
-  let data = bit_builder.from_bit_string(<<1>>)
+  let data =
+    bit_builder.from_bit_string(<<1>>)
     |> bit_builder.append(<<2>>)
     |> bit_builder.append(<<3>>)
     |> bit_builder.prepend(<<0>>)
@@ -17,7 +18,8 @@ pub fn builder_test() {
 }
 
 pub fn builder_with_strings_test() {
-  let data = bit_builder.from_bit_string(<<1>>)
+  let data =
+    bit_builder.from_bit_string(<<1>>)
     |> bit_builder.append_string("2")
     |> bit_builder.append_string("3")
     |> bit_builder.prepend_string("0")
@@ -32,7 +34,8 @@ pub fn builder_with_strings_test() {
 }
 
 pub fn builder_with_builders_test() {
-  let data = bit_builder.from_bit_string(<<1>>)
+  let data =
+    bit_builder.from_bit_string(<<1>>)
     |> bit_builder.append_builder(bit_builder.from_bit_string(<<2>>))
     |> bit_builder.append_builder(bit_builder.from_bit_string(<<3>>))
     |> bit_builder.prepend_builder(bit_builder.from_bit_string(<<0>>))
diff --git a/test/gleam/function_test.gleam b/test/gleam/function_test.gleam
index f5d34a9..9aca032 100644
--- a/test/gleam/function_test.gleam
+++ b/test/gleam/function_test.gleam
@@ -18,7 +18,8 @@ pub fn compose_test() {
 
   // Takes a list of ints and returns the head as a string (if there is one, or
   // else "0" if there is not)
-  let head_to_string = list.head
+  let head_to_string =
+    list.head
     |> function.compose(result.unwrap(_, 0))
     |> function.compose(int.to_string)
 
diff --git a/test/gleam/map_test.gleam b/test/gleam/map_test.gleam
index abd3daf..74641e2 100644
--- a/test/gleam/map_test.gleam
+++ b/test/gleam/map_test.gleam
@@ -111,14 +111,20 @@ pub fn merge_test() {
   let b = map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2)])
 
   map.merge(a, b)
-  |> should.equal(
-    map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2), tuple("d", 3)]),
-  )
+  |> should.equal(map.from_list([
+    tuple("a", 0),
+    tuple("b", 1),
+    tuple("c", 2),
+    tuple("d", 3),
+  ]))
 
   map.merge(b, a)
-  |> should.equal(
-    map.from_list([tuple("a", 2), tuple("b", 1), tuple("c", 4), tuple("d", 3)]),
-  )
+  |> should.equal(map.from_list([
+    tuple("a", 2),
+    tuple("b", 1),
+    tuple("c", 4),
+    tuple("d", 3),
+  ]))
 }
 
 pub fn delete_test() {
@@ -149,15 +155,17 @@ pub fn update_test() {
 
   dict
   |> map.update("z", inc_or_zero)
-  |> should.equal(
-    map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2), tuple("z", 0)]),
-  )
+  |> should.equal(map.from_list([
+    tuple("a", 0),
+    tuple("b", 1),
+    tuple("c", 2),
+    tuple("z", 0),
+  ]))
 }
 
 pub fn fold_test() {
-  let dict = map.from_list(
-    [tuple("a", 0), tuple("b", 1), tuple("c", 2), tuple("d", 3)],
-  )
+  let dict =
+    map.from_list([tuple("a", 0), tuple("b", 1), tuple("c", 2), tuple("d", 3)])
 
   let add = fn(_, v, acc) { v + acc }
 
diff --git a/test/gleam/queue_test.gleam b/test/gleam/queue_test.gleam
index e0e7378..ea38ed3 100644
--- a/test/gleam/queue_test.gleam
+++ b/test/gleam/queue_test.gleam
@@ -88,7 +88,8 @@ pub fn push_front_test() {
 pub fn pop_back_test() {
   // We cannot construct the expected remainaing queue with from_list because
   // it has different internal representation.
-  let expected_rest = queue.new()
+  let expected_rest =
+    queue.new()
     |> queue.push_front(1)
     |> queue.push_front(2)
   queue.from_list([1, 2, 3])
diff --git a/test/gleam/regex_test.gleam b/test/gleam/regex_test.gleam
index 3eecccb..1b45c2d 100644
--- a/test/gleam/regex_test.gleam
+++ b/test/gleam/regex_test.gleam
@@ -15,12 +15,10 @@ pub fn from_string_test() {
   assert Error(from_string_err) = regex.from_string("[0-9")
 
   from_string_err
-  |> should.equal(
-    CompileError(
-      error: "missing terminating ] for character class",
-      byte_index: 4,
-    ),
-  )
+  |> should.equal(CompileError(
+    error: "missing terminating ] for character class",
+    byte_index: 4,
+  ))
 }
 
 pub fn compile_test() {
@@ -69,18 +67,12 @@ pub fn scan_test() {
   assert Ok(re) = regex.from_string("[oi]n a(.?) (\\w+)")
 
   regex.scan(re, "I am on a boat in a lake.")
-  |> should.equal(
-    [
-      Match(
-        content: "on a boat",
-        byte_index: 5,
-        submatches: [None, Some("boat")],
-      ),
-      Match(
-        content: "in a lake",
-        byte_index: 15,
-        submatches: [None, Some("lake")],
-      ),
-    ],
-  )
+  |> should.equal([
+    Match(content: "on a boat", byte_index: 5, submatches: [None, Some("boat")]),
+    Match(
+      content: "in a lake",
+      byte_index: 15,
+      submatches: [None, Some("lake")],
+    ),
+  ])
 }
diff --git a/test/gleam/string_builder_test.gleam b/test/gleam/string_builder_test.gleam
index b2e30cf..fdbd048 100644
--- a/test/gleam/string_builder_test.gleam
+++ b/test/gleam/string_builder_test.gleam
@@ -2,7 +2,8 @@ import gleam/should
 import gleam/string_builder
 
 pub fn string_builder_test() {
-  let data = string_builder.from_string("ello")
+  let data =
+    string_builder.from_string("ello")
     |> string_builder.append(",")
     |> string_builder.append(" world!")
     |> string_builder.prepend("H")
@@ -15,13 +16,13 @@ pub fn string_builder_test() {
   |> string_builder.byte_size
   |> should.equal(13)
 
-  let data = string_builder.from_string("ello")
+  let data =
+    string_builder.from_string("ello")
     |> string_builder.append_builder(string_builder.from_string(","))
-    |> string_builder.append_builder(
-      string_builder.concat(
-        [string_builder.from_string(" wo"), string_builder.from_string("rld!")],
-      ),
-    )
+    |> string_builder.append_builder(string_builder.concat([
+      string_builder.from_string(" wo"),
+      string_builder.from_string("rld!"),
+    ]))
     |> string_builder.prepend_builder(string_builder.from_string("H"))
 
   data
@@ -53,23 +54,19 @@ pub fn split_test() {
   "Gleam,Erlang,Elixir"
   |> string_builder.from_string
   |> string_builder.split(",")
-  |> should.equal(
-    [
-      string_builder.from_string("Gleam"),
-      string_builder.from_string("Erlang"),
-      string_builder.from_string("Elixir"),
-    ],
-  )
+  |> should.equal([
+    string_builder.from_string("Gleam"),
+    string_builder.from_string("Erlang"),
+    string_builder.from_string("Elixir"),
+  ])
 
   ["Gleam, Erl", "ang,Elixir"]
   |> string_builder.from_strings
   |> string_builder.split(", ")
-  |> should.equal(
-    [
-      string_builder.from_string("Gleam"),
-      string_builder.from_strings(["Erl", "ang,Elixir"]),
-    ],
-  )
+  |> should.equal([
+    string_builder.from_string("Gleam"),
+    string_builder.from_strings(["Erl", "ang,Elixir"]),
+  ])
 }
 
 pub fn is_equal_test() {
diff --git a/test/gleam/uri_test.gleam b/test/gleam/uri_test.gleam
index e70874b..55a4bd6 100644
--- a/test/gleam/uri_test.gleam
+++ b/test/gleam/uri_test.gleam
@@ -3,9 +3,8 @@ import gleam/should
 import gleam/option.{None, Some}
 
 pub fn full_parse_test() {
-  assert Ok(
-    parsed,
-  ) = uri.parse("https://foo:bar@example.com:1234/path?query=true#fragment")
+  assert Ok(parsed) =
+    uri.parse("https://foo:bar@example.com:1234/path?query=true#fragment")
   should.equal(parsed.scheme, Some("https"))
   should.equal(parsed.userinfo, Some("foo:bar"))
   should.equal(parsed.host, Some("example.com"))
@@ -42,15 +41,16 @@ pub fn error_parsing_uri_test() {
 }
 
 pub fn full_uri_to_string_test() {
-  assert test_uri = uri.Uri(
-    Some("https"),
-    Some("foo:bar"),
-    Some("example.com"),
-    Some(1234),
-    "/path",
-    Some("query=true"),
-    Some("fragment"),
-  )
+  assert test_uri =
+    uri.Uri(
+      Some("https"),
+      Some("foo:bar"),
+      Some("example.com"),
+      Some(1234),
+      "/path",
+      Some("query=true"),
+      Some("fragment"),
+    )
   should.equal(
     uri.to_string(test_uri),
     "https://foo:bar@example.com:1234/path?query=true#fragment",
@@ -82,9 +82,8 @@ pub fn error_parsing_query_test() {
 }
 
 pub fn query_to_string_test() {
-  assert query_string = uri.query_to_string(
-    [tuple("foo bar", "1"), tuple("city", "örebro")],
-  )
+  assert query_string =
+    uri.query_to_string([tuple("foo bar", "1"), tuple("city", "örebro")])
   should.equal(query_string, "foo+bar=1&city=%C3%B6rebro")
 }