bool and order JS support

5 files changed, 435 insertions, 442 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56ee093..d6a6e56 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- The `bool`, and `order` modules now support JavaScript compilation.
 - The `map.update` function now uses `Option` rather than `Result`.
 - The `iterator` module gains the `fold_until` function.
 
diff --git a/src/gleam/bool.gleam b/src/gleam/bool.gleam
index e25f7b5..684aa2f 100644
--- a/src/gleam/bool.gleam
+++ b/src/gleam/bool.gleam
@@ -1,207 +1,205 @@
-if erlang {
-  import gleam/order.{Order}
+import gleam/order.{Order}
 
-  /// A type with two possible values, True and False. Used to indicate whether
-  /// things are... true or false!
-  ///
-  /// Often is it clearer and offers more type safety to define a custom type
-  /// than to use Bool. For example, rather than having a `is_teacher: Bool`
-  /// field consider having a `role: SchoolRole` field where SchoolRole is a custom
-  /// type that can be either Student or Teacher.
-  ///
-  pub type Bool =
-    Bool
+/// A type with two possible values, True and False. Used to indicate whether
+/// things are... true or false!
+///
+/// Often is it clearer and offers more type safety to define a custom type
+/// than to use Bool. For example, rather than having a `is_teacher: Bool`
+/// field consider having a `role: SchoolRole` field where SchoolRole is a custom
+/// type that can be either Student or Teacher.
+///
+pub type Bool =
+  Bool
 
-  /// Returns the opposite bool value.
-  ///
-  /// This is the same as the `!` or `not` operators in some other languages.
-  ///
-  /// ## Examples
-  ///
-  ///    > negate(True)
-  ///    False
-  ///
-  ///    > negate(False)
-  ///    True
-  ///
-  pub fn negate(bool: Bool) -> Bool {
-    case bool {
-      True -> False
-      False -> True
-    }
+/// Returns the opposite bool value.
+///
+/// This is the same as the `!` or `not` operators in some other languages.
+///
+/// ## Examples
+///
+///    > negate(True)
+///    False
+///
+///    > negate(False)
+///    True
+///
+pub fn negate(bool: Bool) -> Bool {
+  case bool {
+    True -> False
+    False -> True
   }
+}
 
-  /// Returns the nor of two bools
-  ///
-  /// ## Examples
-  ///
-  ///    > nor(False, False)
-  ///    True
-  ///
-  ///    > nor(False, True)
-  ///    False
-  ///
-  ///    > nor(True, False)
-  ///    False
-  ///
-  ///    > nor(True, True)
-  ///    False
-  ///
-  pub fn nor(a: Bool, b: Bool) -> Bool {
-    case a, b {
-      False, False -> True
-      False, True -> False
-      True, False -> False
-      True, True -> False
-    }
+/// Returns the nor of two bools
+///
+/// ## Examples
+///
+///    > nor(False, False)
+///    True
+///
+///    > nor(False, True)
+///    False
+///
+///    > nor(True, False)
+///    False
+///
+///    > nor(True, True)
+///    False
+///
+pub fn nor(a: Bool, b: Bool) -> Bool {
+  case a, b {
+    False, False -> True
+    False, True -> False
+    True, False -> False
+    True, True -> False
   }
+}
 
-  /// Returns the nand of two bools
-  ///
-  /// ## Examples
-  ///
-  ///    > nand(False, False)
-  ///    True
-  ///
-  ///    > nand(False, True)
-  ///    True
-  ///
-  ///    > nand(True, False)
-  ///    True
-  ///
-  ///    > nand(True, True)
-  ///    False
-  ///
-  pub fn nand(a: Bool, b: Bool) -> Bool {
-    case a, b {
-      False, False -> True
-      False, True -> True
-      True, False -> True
-      True, True -> False
-    }
+/// Returns the nand of two bools
+///
+/// ## Examples
+///
+///    > nand(False, False)
+///    True
+///
+///    > nand(False, True)
+///    True
+///
+///    > nand(True, False)
+///    True
+///
+///    > nand(True, True)
+///    False
+///
+pub fn nand(a: Bool, b: Bool) -> Bool {
+  case a, b {
+    False, False -> True
+    False, True -> True
+    True, False -> True
+    True, True -> False
   }
+}
 
-  /// Returns the exclusive or of two bools
-  ///
-  /// ## Examples
-  ///
-  ///    > exclusive_or(False, False)
-  ///    False
-  ///
-  ///    > exclusive_or(False, True)
-  ///    True
-  ///
-  ///    > exclusive_or(True, False)
-  ///    True
-  ///
-  ///    > exclusive_or(True, True)
-  ///    False
-  ///
-  pub fn exclusive_or(a: Bool, b: Bool) -> Bool {
-    case a, b {
-      False, False -> False
-      False, True -> True
-      True, False -> True
-      True, True -> False
-    }
+/// Returns the exclusive or of two bools
+///
+/// ## Examples
+///
+///    > exclusive_or(False, False)
+///    False
+///
+///    > exclusive_or(False, True)
+///    True
+///
+///    > exclusive_or(True, False)
+///    True
+///
+///    > exclusive_or(True, True)
+///    False
+///
+pub fn exclusive_or(a: Bool, b: Bool) -> Bool {
+  case a, b {
+    False, False -> False
+    False, True -> True
+    True, False -> True
+    True, True -> False
   }
+}
 
-  /// Returns the exclusive nor of two bools
-  ///
-  /// ## Examples
-  ///
-  ///    > exclusive_nor(False, False)
-  ///    True
-  ///
-  ///    > exclusive_nor(False, True)
-  ///    False
-  ///
-  ///    > exclusive_nor(True, False)
-  ///    False
-  ///
-  ///    > exclusive_nor(True, True)
-  ///    True
-  ///
-  pub fn exclusive_nor(a: Bool, b: Bool) -> Bool {
-    case a, b {
-      False, False -> True
-      False, True -> False
-      True, False -> False
-      True, True -> True
-    }
+/// Returns the exclusive nor of two bools
+///
+/// ## Examples
+///
+///    > exclusive_nor(False, False)
+///    True
+///
+///    > exclusive_nor(False, True)
+///    False
+///
+///    > exclusive_nor(True, False)
+///    False
+///
+///    > exclusive_nor(True, True)
+///    True
+///
+pub fn exclusive_nor(a: Bool, b: Bool) -> Bool {
+  case a, b {
+    False, False -> True
+    False, True -> False
+    True, False -> False
+    True, True -> True
   }
+}
 
-  /// Compares two bools and returns the first values Order to the second.
-  ///
-  /// ## Examples
-  ///
-  ///    > import gleam/order
-  ///    > compare(True, False)
-  ///    order.Gt
-  ///
-  pub fn compare(a: Bool, with b: Bool) -> Order {
-    case a, b {
-      True, True -> order.Eq
-      True, False -> order.Gt
-      False, False -> order.Eq
-      False, True -> order.Lt
-    }
+/// Compares two bools and returns the first values Order to the second.
+///
+/// ## Examples
+///
+///    > import gleam/order
+///    > compare(True, False)
+///    order.Gt
+///
+pub fn compare(a: Bool, with b: Bool) -> Order {
+  case a, b {
+    True, True -> order.Eq
+    True, False -> order.Gt
+    False, False -> order.Eq
+    False, True -> order.Lt
   }
+}
 
-  /// Returns True if either bool value is True.
-  ///
-  /// ## Examples
-  ///
-  ///    > max(True, False)
-  ///    True
-  ///
-  ///    > max(False, True)
-  ///    True
-  ///
-  ///    > max(False, False)
-  ///    False
-  ///
-  pub fn max(a: Bool, b: Bool) -> Bool {
-    case a {
-      True -> True
-      False -> b
-    }
+/// Returns True if either bool value is True.
+///
+/// ## Examples
+///
+///    > max(True, False)
+///    True
+///
+///    > max(False, True)
+///    True
+///
+///    > max(False, False)
+///    False
+///
+pub fn max(a: Bool, b: Bool) -> Bool {
+  case a {
+    True -> True
+    False -> b
   }
+}
 
-  /// Returns False if either bool value is False.
-  ///
-  /// ## Examples
-  ///
-  ///    > max(True, False)
-  ///    False
-  ///
-  ///    > max(False, True)
-  ///    False
-  ///
-  ///    > max(False, False)
-  ///    False
-  ///
-  pub fn min(a: Bool, b: Bool) -> Bool {
-    case a {
-      False -> False
-      True -> b
-    }
+/// Returns False if either bool value is False.
+///
+/// ## Examples
+///
+///    > max(True, False)
+///    False
+///
+///    > max(False, True)
+///    False
+///
+///    > max(False, False)
+///    False
+///
+pub fn min(a: Bool, b: Bool) -> Bool {
+  case a {
+    False -> False
+    True -> b
   }
+}
 
-  /// Returns a numeric representation of the given bool.
-  ///
-  /// ## Examples
-  ///
-  ///    > to_int(True)
-  ///    1
-  ///
-  ///    > to_int(False)
-  ///    0
-  ///
-  pub fn to_int(bool: Bool) -> Int {
-    case bool {
-      False -> 0
-      True -> 1
-    }
+/// Returns a numeric representation of the given bool.
+///
+/// ## Examples
+///
+///    > to_int(True)
+///    1
+///
+///    > to_int(False)
+///    0
+///
+pub fn to_int(bool: Bool) -> Int {
+  case bool {
+    False -> 0
+    True -> 1
   }
 }
diff --git a/src/gleam/order.gleam b/src/gleam/order.gleam
index ee81a62..c030db4 100644
--- a/src/gleam/order.gleam
+++ b/src/gleam/order.gleam
@@ -1,103 +1,101 @@
-if erlang {
-  /// Represents the result of a single comparison to determine the precise
-  /// ordering of two values.
-  ///
-  pub type Order {
-    /// Less-than
-    Lt
+/// Represents the result of a single comparison to determine the precise
+/// ordering of two values.
+///
+pub type Order {
+  /// Less-than
+  Lt
 
-    /// Equal
-    Eq
+  /// Equal
+  Eq
 
-    /// Greater than
-    Gt
-  }
+  /// Greater than
+  Gt
+}
 
-  /// Inverts an order, so less-than becomes greater-than and greater-than
-  /// becomes less-than.
-  ///
-  /// ## Examples
-  ///
-  ///    > reverse(Lt)
-  ///    Gt
-  ///
-  ///    > reverse(Eq)
-  ///    Eq
-  ///
-  ///    > reverse(Lt)
-  ///    Gt
-  ///
-  pub fn reverse(order: Order) -> Order {
-    case order {
-      Lt -> Gt
-      Eq -> Eq
-      Gt -> Lt
-    }
+/// Inverts an order, so less-than becomes greater-than and greater-than
+/// becomes less-than.
+///
+/// ## Examples
+///
+///    > reverse(Lt)
+///    Gt
+///
+///    > reverse(Eq)
+///    Eq
+///
+///    > reverse(Lt)
+///    Gt
+///
+pub fn reverse(order: Order) -> Order {
+  case order {
+    Lt -> Gt
+    Eq -> Eq
+    Gt -> Lt
   }
+}
 
-  /// Produces a numeric representation of the order.
-  ///
-  /// ## Examples
-  ///
-  ///    > to_int(Lt)
-  ///    -1
-  ///
-  ///    > to_int(Eq)
-  ///    0
-  ///
-  ///    > to_int(Gt)
-  ///    1
-  ///
-  pub fn to_int(order: Order) -> Int {
-    case order {
-      Lt -> -1
-      Eq -> 0
-      Gt -> 1
-    }
+/// Produces a numeric representation of the order.
+///
+/// ## Examples
+///
+///    > to_int(Lt)
+///    -1
+///
+///    > to_int(Eq)
+///    0
+///
+///    > to_int(Gt)
+///    1
+///
+pub fn to_int(order: Order) -> Int {
+  case order {
+    Lt -> -1
+    Eq -> 0
+    Gt -> 1
   }
+}
 
-  /// Compares two Order values to one another, producing a new Order.
-  ///
-  /// ## Examples
-  ///
-  ///    > compare(Eq, with: Lt)
-  ///    Gt
-  ///
-  pub fn compare(a: Order, with b: Order) -> Order {
-    case a, b {
-      x, y if x == y -> Eq
-      Lt, _ | Eq, Gt -> Lt
-      _, _ -> Gt
-    }
+/// Compares two Order values to one another, producing a new Order.
+///
+/// ## Examples
+///
+///    > compare(Eq, with: Lt)
+///    Gt
+///
+pub fn compare(a: Order, with b: Order) -> Order {
+  case a, b {
+    x, y if x == y -> Eq
+    Lt, _ | Eq, Gt -> Lt
+    _, _ -> Gt
   }
+}
 
-  /// Returns the largest of two orders.
-  ///
-  /// ## Examples
-  ///
-  ///    > max(Eq, Lt)
-  ///    Eq
-  ///
-  pub fn max(a: Order, b: Order) -> Order {
-    case a, b {
-      Gt, _ -> Gt
-      Eq, Lt -> Eq
-      _, _ -> b
-    }
+/// Returns the largest of two orders.
+///
+/// ## Examples
+///
+///    > max(Eq, Lt)
+///    Eq
+///
+pub fn max(a: Order, b: Order) -> Order {
+  case a, b {
+    Gt, _ -> Gt
+    Eq, Lt -> Eq
+    _, _ -> b
   }
+}
 
-  /// Returns the smallest of two orders.
-  ///
-  /// ## Examples
-  ///
-  ///    > min(Eq, Lt)
-  ///    Lt
-  ///
-  pub fn min(a: Order, b: Order) -> Order {
-    case a, b {
-      Lt, _ -> Lt
-      Eq, Gt -> Eq
-      _, _ -> b
-    }
+/// Returns the smallest of two orders.
+///
+/// ## Examples
+///
+///    > min(Eq, Lt)
+///    Lt
+///
+pub fn min(a: Order, b: Order) -> Order {
+  case a, b {
+    Lt, _ -> Lt
+    Eq, Gt -> Eq
+    _, _ -> b
   }
 }
diff --git a/test/gleam/bool_test.gleam b/test/gleam/bool_test.gleam
index 9658377..3edea25 100644
--- a/test/gleam/bool_test.gleam
+++ b/test/gleam/bool_test.gleam
@@ -1,119 +1,117 @@
-if erlang {
-  import gleam/bool
-  import gleam/order
-  import gleam/should
+import gleam/bool
+import gleam/order
+import gleam/should
 
-  pub fn negate_test() {
-    bool.negate(True)
-    |> should.be_false
+pub fn negate_test() {
+  bool.negate(True)
+  |> should.be_false
 
-    bool.negate(False)
-    |> should.be_true
-  }
+  bool.negate(False)
+  |> should.be_true
+}
 
-  pub fn nor_test() {
-    bool.nor(False, False)
-    |> should.be_true
+pub fn nor_test() {
+  bool.nor(False, False)
+  |> should.be_true
 
-    bool.nor(False, True)
-    |> should.be_false
+  bool.nor(False, True)
+  |> should.be_false
 
-    bool.nor(True, False)
-    |> should.be_false
+  bool.nor(True, False)
+  |> should.be_false
 
-    bool.nor(True, True)
-    |> should.be_false
-  }
+  bool.nor(True, True)
+  |> should.be_false
+}
 
-  pub fn nand_test() {
-    bool.nand(False, False)
-    |> should.be_true
+pub fn nand_test() {
+  bool.nand(False, False)
+  |> should.be_true
 
-    bool.nand(False, True)
-    |> should.be_true
+  bool.nand(False, True)
+  |> should.be_true
 
-    bool.nand(True, False)
-    |> should.be_true
+  bool.nand(True, False)
+  |> should.be_true
 
-    bool.nand(True, True)
-    |> should.be_false
-  }
+  bool.nand(True, True)
+  |> should.be_false
+}
 
-  pub fn exclusive_or_test() {
-    bool.exclusive_or(True, True)
-    |> should.be_false
+pub fn exclusive_or_test() {
+  bool.exclusive_or(True, True)
+  |> should.be_false
 
-    bool.exclusive_or(False, False)
-    |> should.be_false
+  bool.exclusive_or(False, False)
+  |> should.be_false
 
-    bool.exclusive_or(True, False)
-    |> should.be_true
+  bool.exclusive_or(True, False)
+  |> should.be_true
 
-    bool.exclusive_or(False, True)
-    |> should.be_true
-  }
+  bool.exclusive_or(False, True)
+  |> should.be_true
+}
 
-  pub fn exclusive_nor_test() {
-    bool.exclusive_nor(False, False)
-    |> should.be_true
+pub fn exclusive_nor_test() {
+  bool.exclusive_nor(False, False)
+  |> should.be_true
 
-    bool.exclusive_nor(False, True)
-    |> should.be_false
+  bool.exclusive_nor(False, True)
+  |> should.be_false
 
-    bool.exclusive_nor(True, False)
-    |> should.be_false
+  bool.exclusive_nor(True, False)
+  |> should.be_false
 
-    bool.exclusive_nor(True, True)
-    |> should.be_true
-  }
+  bool.exclusive_nor(True, True)
+  |> should.be_true
+}
 
-  pub fn compare_test() {
-    bool.compare(True, True)
-    |> should.equal(order.Eq)
+pub fn compare_test() {
+  bool.compare(True, True)
+  |> should.equal(order.Eq)
 
-    bool.compare(True, False)
-    |> should.equal(order.Gt)
+  bool.compare(True, False)
+  |> should.equal(order.Gt)
 
-    bool.compare(False, False)
-    |> should.equal(order.Eq)
+  bool.compare(False, False)
+  |> should.equal(order.Eq)
 
-    bool.compare(False, True)
-    |> should.equal(order.Lt)
-  }
+  bool.compare(False, True)
+  |> should.equal(order.Lt)
+}
 
-  pub fn max_test() {
-    bool.max(True, True)
-    |> should.equal(True)
+pub fn max_test() {
+  bool.max(True, True)
+  |> should.equal(True)
 
-    bool.max(True, False)
-    |> should.equal(True)
+  bool.max(True, False)
+  |> should.equal(True)
 
-    bool.max(False, False)
-    |> should.equal(False)
+  bool.max(False, False)
+  |> should.equal(False)
 
-    bool.max(False, True)
-    |> should.equal(True)
-  }
+  bool.max(False, True)
+  |> should.equal(True)
+}
 
-  pub fn min_test() {
-    bool.min(True, True)
-    |> should.equal(True)
+pub fn min_test() {
+  bool.min(True, True)
+  |> should.equal(True)
 
-    bool.min(True, False)
-    |> should.equal(False)
+  bool.min(True, False)
+  |> should.equal(False)
 
-    bool.min(False, False)
-    |> should.equal(False)
+  bool.min(False, False)
+  |> should.equal(False)
 
-    bool.min(False, True)
-    |> should.equal(False)
-  }
+  bool.min(False, True)
+  |> should.equal(False)
+}
 
-  pub fn to_int_test() {
-    bool.to_int(True)
-    |> should.equal(1)
+pub fn to_int_test() {
+  bool.to_int(True)
+  |> should.equal(1)
 
-    bool.to_int(False)
-    |> should.equal(0)
-  }
+  bool.to_int(False)
+  |> should.equal(0)
 }
diff --git a/test/gleam/order_test.gleam b/test/gleam/order_test.gleam
index 95cd6e8..2517f9c 100644
--- a/test/gleam/order_test.gleam
+++ b/test/gleam/order_test.gleam
@@ -1,113 +1,111 @@
-if erlang {
-  import gleam/should
-  import gleam/order.{Eq, Gt, Lt}
+import gleam/should
+import gleam/order.{Eq, Gt, Lt}
 
-  pub fn reverse_test() {
-    order.reverse(Lt)
-    |> should.equal(Gt)
+pub fn reverse_test() {
+  order.reverse(Lt)
+  |> should.equal(Gt)
 
-    order.reverse(Eq)
-    |> should.equal(Eq)
+  order.reverse(Eq)
+  |> should.equal(Eq)
 
-    order.reverse(Gt)
-    |> should.equal(Lt)
-  }
+  order.reverse(Gt)
+  |> should.equal(Lt)
+}
 
-  pub fn to_int_test() {
-    order.to_int(Lt)
-    |> should.equal(-1)
+pub fn to_int_test() {
+  order.to_int(Lt)
+  |> should.equal(-1)
 
-    order.to_int(Eq)
-    |> should.equal(0)
+  order.to_int(Eq)
+  |> should.equal(0)
 
-    order.to_int(Gt)
-    |> should.equal(1)
-  }
+  order.to_int(Gt)
+  |> should.equal(1)
+}
 
-  pub fn compare_test() {
-    order.compare(Lt, Lt)
-    |> should.equal(Eq)
+pub fn compare_test() {
+  order.compare(Lt, Lt)
+  |> should.equal(Eq)
 
-    order.compare(Lt, Eq)
-    |> should.equal(Lt)
+  order.compare(Lt, Eq)
+  |> should.equal(Lt)
 
-    order.compare(Lt, Gt)
-    |> should.equal(Lt)
+  order.compare(Lt, Gt)
+  |> should.equal(Lt)
 
-    order.compare(Eq, Lt)
-    |> should.equal(Gt)
+  order.compare(Eq, Lt)
+  |> should.equal(Gt)
 
-    order.compare(Eq, Eq)
-    |> should.equal(Eq)
+  order.compare(Eq, Eq)
+  |> should.equal(Eq)
 
-    order.compare(Eq, Gt)
-    |> should.equal(Lt)
+  order.compare(Eq, Gt)
+  |> should.equal(Lt)
 
-    order.compare(Gt, Lt)
-    |> should.equal(Gt)
+  order.compare(Gt, Lt)
+  |> should.equal(Gt)
 
-    order.compare(Gt, Eq)
-    |> should.equal(Gt)
+  order.compare(Gt, Eq)
+  |> should.equal(Gt)
 
-    order.compare(Gt, Gt)
-    |> should.equal(Eq)
-  }
+  order.compare(Gt, Gt)
+  |> should.equal(Eq)
+}
 
-  pub fn max_test() {
-    order.max(Lt, Lt)
-    |> should.equal(Lt)
+pub fn max_test() {
+  order.max(Lt, Lt)
+  |> should.equal(Lt)
 
-    order.max(Lt, Eq)
-    |> should.equal(Eq)
+  order.max(Lt, Eq)
+  |> should.equal(Eq)
 
-    order.max(Lt, Gt)
-    |> should.equal(Gt)
+  order.max(Lt, Gt)
+  |> should.equal(Gt)
 
-    order.max(Eq, Lt)
-    |> should.equal(Eq)
+  order.max(Eq, Lt)
+  |> should.equal(Eq)
 
-    order.max(Eq, Eq)
-    |> should.equal(Eq)
+  order.max(Eq, Eq)
+  |> should.equal(Eq)
 
-    order.max(Eq, Gt)
-    |> should.equal(Gt)
+  order.max(Eq, Gt)
+  |> should.equal(Gt)
 
-    order.max(Gt, Lt)
-    |> should.equal(Gt)
+  order.max(Gt, Lt)
+  |> should.equal(Gt)
 
-    order.max(Gt, Eq)
-    |> should.equal(Gt)
+  order.max(Gt, Eq)
+  |> should.equal(Gt)
 
-    order.max(Gt, Gt)
-    |> should.equal(Gt)
-  }
+  order.max(Gt, Gt)
+  |> should.equal(Gt)
+}
 
-  pub fn min_test() {
-    order.min(Lt, Lt)
-    |> should.equal(Lt)
+pub fn min_test() {
+  order.min(Lt, Lt)
+  |> should.equal(Lt)
 
-    order.min(Lt, Eq)
-    |> should.equal(Lt)
+  order.min(Lt, Eq)
+  |> should.equal(Lt)
 
-    order.min(Lt, Gt)
-    |> should.equal(Lt)
+  order.min(Lt, Gt)
+  |> should.equal(Lt)
 
-    order.min(Eq, Lt)
-    |> should.equal(Lt)
+  order.min(Eq, Lt)
+  |> should.equal(Lt)
 
-    order.min(Eq, Eq)
-    |> should.equal(Eq)
+  order.min(Eq, Eq)
+  |> should.equal(Eq)
 
-    order.min(Eq, Gt)
-    |> should.equal(Eq)
+  order.min(Eq, Gt)
+  |> should.equal(Eq)
 
-    order.min(Gt, Lt)
-    |> should.equal(Lt)
+  order.min(Gt, Lt)
+  |> should.equal(Lt)
 
-    order.min(Gt, Eq)
-    |> should.equal(Eq)
+  order.min(Gt, Eq)
+  |> should.equal(Eq)
 
-    order.min(Gt, Gt)
-    |> should.equal(Gt)
-  }
+  order.min(Gt, Gt)
+  |> should.equal(Gt)
 }