Remove extra qualification

Author: lpil

test/gleam/order_test.gleam

@@ -5,8 +5,8 @@ pub fn reverse_test() {
   order.reverse(Lt)
   |> should.equal(Gt)
 
-  order.reverse(order.Eq)
-  |> should.equal(order.Eq)
+  order.reverse(Eq)
+  |> should.equal(Eq)
 
   order.reverse(Gt)
   |> should.equal(Lt)
@@ -16,7 +16,7 @@ pub fn to_int_test() {
   order.to_int(Lt)
   |> should.equal(-1)
 
-  order.to_int(order.Eq)
+  order.to_int(Eq)
   |> should.equal(0)
 
   order.to_int(Gt)
@@ -25,56 +25,56 @@ pub fn to_int_test() {
 
 pub fn compare_test() {
   order.compare(Lt, Lt)
-  |> should.equal(order.Eq)
+  |> should.equal(Eq)
 
-  order.compare(Lt, order.Eq)
+  order.compare(Lt, Eq)
   |> should.equal(Lt)
 
   order.compare(Lt, Gt)
   |> should.equal(Lt)
 
-  order.compare(order.Eq, Lt)
+  order.compare(Eq, Lt)
   |> should.equal(Gt)
 
-  order.compare(order.Eq, order.Eq)
-  |> should.equal(order.Eq)
+  order.compare(Eq, Eq)
+  |> should.equal(Eq)
 
-  order.compare(order.Eq, Gt)
+  order.compare(Eq, Gt)
   |> should.equal(Lt)
 
   order.compare(Gt, Lt)
   |> should.equal(Gt)
 
-  order.compare(Gt, order.Eq)
+  order.compare(Gt, Eq)
   |> should.equal(Gt)
 
   order.compare(Gt, Gt)
-  |> should.equal(order.Eq)
+  |> should.equal(Eq)
 }
 
 pub fn max_test() {
   order.max(Lt, Lt)
   |> should.equal(Lt)
 
-  order.max(Lt, order.Eq)
-  |> should.equal(order.Eq)
+  order.max(Lt, Eq)
+  |> should.equal(Eq)
 
   order.max(Lt, Gt)
   |> should.equal(Gt)
 
-  order.max(order.Eq, Lt)
-  |> should.equal(order.Eq)
+  order.max(Eq, Lt)
+  |> should.equal(Eq)
 
-  order.max(order.Eq, order.Eq)
-  |> should.equal(order.Eq)
+  order.max(Eq, Eq)
+  |> should.equal(Eq)
 
-  order.max(order.Eq, Gt)
+  order.max(Eq, Gt)
   |> should.equal(Gt)
 
   order.max(Gt, Lt)
   |> should.equal(Gt)
 
-  order.max(Gt, order.Eq)
+  order.max(Gt, Eq)
   |> should.equal(Gt)
 
   order.max(Gt, Gt)
@@ -85,26 +85,26 @@ pub fn min_test() {
   order.min(Lt, Lt)
   |> should.equal(Lt)
 
-  order.min(Lt, order.Eq)
+  order.min(Lt, Eq)
   |> should.equal(Lt)
 
   order.min(Lt, Gt)
   |> should.equal(Lt)
 
-  order.min(order.Eq, Lt)
+  order.min(Eq, Lt)
   |> should.equal(Lt)
 
-  order.min(order.Eq, order.Eq)
-  |> should.equal(order.Eq)
+  order.min(Eq, Eq)
+  |> should.equal(Eq)
 
-  order.min(order.Eq, Gt)
-  |> should.equal(order.Eq)
+  order.min(Eq, Gt)
+  |> should.equal(Eq)
 
   order.min(Gt, Lt)
   |> should.equal(Lt)
 
-  order.min(Gt, order.Eq)
-  |> should.equal(order.Eq)
+  order.min(Gt, Eq)
+  |> should.equal(Eq)
 
   order.min(Gt, Gt)
   |> should.equal(Gt)