Correct namespace operator in examples

4 files changed, 101 insertions, 101 deletions

diff --git a/src/Bool.gleam b/src/Bool.gleam
index 6d6843d..da8800d 100644
--- a/src/Bool.gleam
+++ b/src/Bool.gleam
@@ -16,10 +16,10 @@ pub fn not(bool) {
 
 test not {
   not(True)
-    |> Assert.false
+    |> Assert:false
 
   not(False)
-    |> Assert.true
+    |> Assert:true
 }
 
 pub fn compare(a, b) {
@@ -33,16 +33,16 @@ pub fn compare(a, b) {
 
 test compare {
   compare(True, True)
-    |> Assert.equal(_, Order:EQ)
+    |> Assert:equal(_, Order:EQ)
 
   compare(True, False)
-    |> Assert.equal(_, Order:GT)
+    |> Assert:equal(_, Order:GT)
 
   compare(False, False)
-    |> Assert.equal(_, Order:LT)
+    |> Assert:equal(_, Order:LT)
 
   compare(False, True)
-    |> Assert.equal(_, Order:GT)
+    |> Assert:equal(_, Order:GT)
 }
 
 pub fn max(a, b) {
@@ -54,16 +54,16 @@ pub fn max(a, b) {
 
 test max {
   max(True, True)
-    |> Assert.equal(_, True)
+    |> Assert:equal(_, True)
 
   max(True, False)
-    |> Assert.equal(_, True)
+    |> Assert:equal(_, True)
 
   max(False, False)
-    |> Assert.equal(_, False)
+    |> Assert:equal(_, False)
 
   max(False, True)
-    |> Assert.equal(_, True)
+    |> Assert:equal(_, True)
 }
 
 pub fn min(a, b) {
@@ -75,16 +75,16 @@ pub fn min(a, b) {
 
 test min {
   min(True, True)
-    |> Assert.equal(_, True)
+    |> Assert:equal(_, True)
 
   min(True, False)
-    |> Assert.equal(_, False)
+    |> Assert:equal(_, False)
 
   min(False, False)
-    |> Assert.equal(_, False)
+    |> Assert:equal(_, False)
 
   min(False, True)
-    |> Assert.equal(_, False)
+    |> Assert:equal(_, False)
 }
 
 pub fn to_int(bool) {
@@ -96,8 +96,8 @@ pub fn to_int(bool) {
 
 test to_int {
   to_int(True)
-    |> Assert.equal(_, 1)
+    |> Assert:equal(_, 1)
 
   to_int(False)
-    |> Assert.equal(_, 0)
+    |> Assert:equal(_, 0)
 }
diff --git a/src/List.gleam b/src/List.gleam
index acd349c..f249234 100644
--- a/src/List.gleam
+++ b/src/List.gleam
@@ -10,10 +10,10 @@ pub type Err =
 pub external fn length(List(a)) { Int } = 'erlang' 'length'
 
 test length {
-  length([]) |> Assert.equal(_, 0)
-  length([1]) |> Assert.equal(_, 1)
-  length([1, 1]) |> Assert.equal(_, 2)
-  length([1, 1, 1]) |> Assert.equal(_, 3)
+  length([]) |> Assert:equal(_, 0)
+  length([1]) |> Assert:equal(_, 1)
+  length([1, 1]) |> Assert:equal(_, 2)
+  length([1, 1, 1]) |> Assert:equal(_, 3)
 }
 
 // Using the Erlang C BIF implementation.
@@ -21,8 +21,8 @@ test length {
 pub external fn reverse(List(a)) { List(a) } = 'erlang' 'reverse'
 
 test reverse {
-  length([]) |> Assert.equal(_, [])
-  length([1, 2, 3, 4, 5]) |> Assert.equal(_, [5, 4, 3, 2, 1])
+  length([]) |> Assert:equal(_, [])
+  length([1, 2, 3, 4, 5]) |> Assert:equal(_, [5, 4, 3, 2, 1])
 }
 
 pub fn is_empty(list) {
@@ -30,8 +30,8 @@ pub fn is_empty(list) {
 }
 
 test is_empty {
-  is_empty([]) |> Assert.true
-  is_empty([1]) |> Assert.false
+  is_empty([]) |> Assert:true
+  is_empty([1]) |> Assert:false
 }
 
 pub fn member(list, elem) {
@@ -43,9 +43,9 @@ pub fn member(list, elem) {
 }
 
 test is_member {
-  is_member([0, 4, 5, 1], 1) |> Assert.true
-  is_member([0, 4, 5, 7], 1) |> Assert.false
-  is_member([], 1) |> Assert.false
+  is_member([0, 4, 5, 1], 1) |> Assert:true
+  is_member([0, 4, 5, 7], 1) |> Assert:false
+  is_member([], 1) |> Assert:false
 }
 
 pub fn head(list) {
@@ -57,10 +57,10 @@ pub fn head(list) {
 
 test head {
   head([0, 4, 5, 7])
-    |> Assert.equal(_, Ok(0))
+    |> Assert:equal(_, Ok(0))
 
   head([])
-    |> Assert.equal(_, Error(Err:Empty))
+    |> Assert:equal(_, Error(Err:Empty))
 }
 
 pub fn tail(list) {
@@ -72,13 +72,13 @@ pub fn tail(list) {
 
 test tail {
   tail([0, 4, 5, 7])
-    |> Assert.equal(_, Ok([4, 5, 7]))
+    |> Assert:equal(_, Ok([4, 5, 7]))
 
   tail([0])
-    |> Assert.equal(_, Ok([]))
+    |> Assert:equal(_, Ok([]))
 
   tail([])
-    |> Assert.equal(_, Error(Err:Empty))
+    |> Assert:equal(_, Error(Err:Empty))
 }
 
 pub fn filter(list, fun) {
@@ -88,19 +88,19 @@ pub fn filter(list, fun) {
 test filter {
   []
     |> filter(_, fn(x) { True })
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
 
   [0, 4, 5, 7, 3]
     |> filter(_, fn(x) { True })
-    |> Assert.equal(_, [0, 4, 5, 7, 3])
+    |> Assert:equal(_, [0, 4, 5, 7, 3])
 
   [0, 4, 5, 7, 3]
     |> filter(_, fn(x) { x > 4 })
-    |> Assert.equal(_, [5, 7])
+    |> Assert:equal(_, [5, 7])
 
   [0, 4, 5, 7, 3]
     |> filter(_, fn(x) { x < 4 })
-    |> Assert.equal(_, [0, 3])
+    |> Assert:equal(_, [0, 3])
 }
 
 fn do_filter(list, fun, acc) {
@@ -123,11 +123,11 @@ pub fn map(list, fun) {
 test map {
   []
     |> map(_, fn(x) { x * 2 })
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
 
   [0, 4, 5, 7, 3]
     |> map(_, fn(x) { x * 2 })
-    |> Assert.equal(_, [0, 8, 10, 14, 6])
+    |> Assert:equal(_, [0, 8, 10, 14, 6])
 }
 
 fn do_map(list, fun, acc) {
@@ -151,11 +151,11 @@ pub fn drop(list, n) {
 test drop/2 {
   []
     |> drop(_, 5)
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
 
   [1, 2, 3, 4, 5, 6, 7, 8]
     |> drop(_, 5)
-    |> Assert.equal(_, [6, 7, 8])
+    |> Assert:equal(_, [6, 7, 8])
 }
 
 pub fn take(list, n) {
@@ -176,10 +176,10 @@ fn do_take(list, n, acc) {
 test take {
   []
     |> take(_, 5)
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
   [1, 2, 3, 4, 5, 6, 7, 8]
     |> take(_, 5)
-    |> Assert.equal(_, [1, 2, 3, 4, 5])
+    |> Assert:equal(_, [1, 2, 3, 4, 5])
 }
 
 pub fn of(x) {
@@ -187,8 +187,8 @@ pub fn of(x) {
 }
 
 test of() {
-  of([]) |> Assert.equal(_, [[]])
-  of(1) |> Assert.equal(_, [1])
+  of([]) |> Assert:equal(_, [[]])
+  of(1) |> Assert:equal(_, [1])
 }
 
 pub fn new() {
@@ -196,7 +196,7 @@ pub fn new() {
 }
 
 test new() {
-  new() |> Assert.equal(_, [])
+  new() |> Assert:equal(_, [])
 }
 
 pub fn flatten(lists) {
@@ -205,16 +205,16 @@ pub fn flatten(lists) {
 
 test flatten() {
   flatten([])
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
 
   flatten([[]])
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
 
   flatten([[], [], []])
-    |> Assert.equal(_, [])
+    |> Assert:equal(_, [])
 
   flatten([[1, 2], [], [3, 4]])
-    |> Assert.equal(_, [1, 2, 3, 4])
+    |> Assert:equal(_, [1, 2, 3, 4])
 }
 
 fn do_flatten(lists, acc) {
@@ -234,7 +234,7 @@ pub fn foldl(list, acc, fun) {
 test foldl() {
   [1, 2, 3]
     |> foldl(_, [], fn(x, acc) { x :: acc })
-    |> Assert.equal(_, [3, 2, 1])
+    |> Assert:equal(_, [3, 2, 1])
 }
 
 pub fn foldr(list, acc, fun) {
@@ -247,5 +247,5 @@ pub fn foldr(list, acc, fun) {
 test foldr() {
   [1, 2, 3]
     |> foldr(_, [], fn(x, acc) { x :: acc })
-    |> Assert.equal(_, [1, 2, 3])
+    |> Assert:equal(_, [1, 2, 3])
 }
diff --git a/src/Order.gleam b/src/Order.gleam
index 34e0dcc..dcfab15 100644
--- a/src/Order.gleam
+++ b/src/Order.gleam
@@ -15,9 +15,9 @@ pub fn reverse(order) {
 }
 
 test reverse {
-  reverse(LT) |> Assert.equal(_, GT)
-  reverse(EQ) |> Assert.equal(_, EQ)
-  reverse(GT) |> Assert.equal(_, LT)
+  reverse(LT) |> Assert:equal(_, GT)
+  reverse(EQ) |> Assert:equal(_, EQ)
+  reverse(GT) |> Assert:equal(_, LT)
 }
 
 pub fn to_int(order) {
@@ -29,9 +29,9 @@ pub fn to_int(order) {
 }
 
 test to_int {
-  to_int(LT) |> Assert.equal(_, -1)
-  to_int(EQ) |> Assert.equal(_, 0)
-  to_int(GT) |> Assert.equal(_, 1)
+  to_int(LT) |> Assert:equal(_, -1)
+  to_int(EQ) |> Assert:equal(_, 0)
+  to_int(GT) |> Assert:equal(_, 1)
 }
 
 pub fn compare(a, b) {
@@ -46,15 +46,15 @@ pub fn compare(a, b) {
 }
 
 test compare {
-  compare(LT, LT) |> Assert.equal(_, EQ)
-  compare(LT, EQ) |> Assert.equal(_, LT)
-  compare(LT, GT) |> Assert.equal(_, LT)
-  compare(EQ, LT) |> Assert.equal(_, GT)
-  compare(EQ, EQ) |> Assert.equal(_, EQ)
-  compare(EQ, GT) |> Assert.equal(_, LT)
-  compare(GT, LT) |> Assert.equal(_, GT)
-  compare(GT, EQ) |> Assert.equal(_, GT)
-  compare(GT, GT) |> Assert.equal(_, EQ)
+  compare(LT, LT) |> Assert:equal(_, EQ)
+  compare(LT, EQ) |> Assert:equal(_, LT)
+  compare(LT, GT) |> Assert:equal(_, LT)
+  compare(EQ, LT) |> Assert:equal(_, GT)
+  compare(EQ, EQ) |> Assert:equal(_, EQ)
+  compare(EQ, GT) |> Assert:equal(_, LT)
+  compare(GT, LT) |> Assert:equal(_, GT)
+  compare(GT, EQ) |> Assert:equal(_, GT)
+  compare(GT, GT) |> Assert:equal(_, EQ)
 }
 
 pub fn max(a, b) {
@@ -66,15 +66,15 @@ pub fn max(a, b) {
 }
 
 test max {
-  max(LT, LT) |> Assert.equal(_, LT)
-  max(LT, EQ) |> Assert.equal(_, EQ)
-  max(LT, GT) |> Assert.equal(_, GT)
-  max(EQ, LT) |> Assert.equal(_, EQ)
-  max(EQ, EQ) |> Assert.equal(_, EQ)
-  max(EQ, GT) |> Assert.equal(_, GT)
-  max(GT, LT) |> Assert.equal(_, GT)
-  max(GT, EQ) |> Assert.equal(_, GT)
-  max(GT, GT) |> Assert.equal(_, GT)
+  max(LT, LT) |> Assert:equal(_, LT)
+  max(LT, EQ) |> Assert:equal(_, EQ)
+  max(LT, GT) |> Assert:equal(_, GT)
+  max(EQ, LT) |> Assert:equal(_, EQ)
+  max(EQ, EQ) |> Assert:equal(_, EQ)
+  max(EQ, GT) |> Assert:equal(_, GT)
+  max(GT, LT) |> Assert:equal(_, GT)
+  max(GT, EQ) |> Assert:equal(_, GT)
+  max(GT, GT) |> Assert:equal(_, GT)
 }
 
 pub fn min(a, b) {
@@ -86,13 +86,13 @@ pub fn min(a, b) {
 }
 
 test min {
-  min(LT, LT) |> Assert.equal(_, LT)
-  min(LT, EQ) |> Assert.equal(_, LT)
-  min(LT, GT) |> Assert.equal(_, LT)
-  min(EQ, LT) |> Assert.equal(_, LT)
-  min(EQ, EQ) |> Assert.equal(_, EQ)
-  min(EQ, GT) |> Assert.equal(_, EQ)
-  min(GT, LT) |> Assert.equal(_, LT)
-  min(GT, EQ) |> Assert.equal(_, EQ)
-  min(GT, GT) |> Assert.equal(_, GT)
+  min(LT, LT) |> Assert:equal(_, LT)
+  min(LT, EQ) |> Assert:equal(_, LT)
+  min(LT, GT) |> Assert:equal(_, LT)
+  min(EQ, LT) |> Assert:equal(_, LT)
+  min(EQ, EQ) |> Assert:equal(_, EQ)
+  min(EQ, GT) |> Assert:equal(_, EQ)
+  min(GT, LT) |> Assert:equal(_, LT)
+  min(GT, EQ) |> Assert:equal(_, EQ)
+  min(GT, GT) |> Assert:equal(_, GT)
 }
diff --git a/src/Result.gleam b/src/Result.gleam
index e5ecf46..d3cce71 100644
--- a/src/Result.gleam
+++ b/src/Result.gleam
@@ -2,7 +2,7 @@ doc """
 Result represents the result of something that may succeed or fail.
 `Ok` means it was successful, `Error` means it failed.
 """
-pub type Result(error, value) {
+pub type Result(error, value) =
   | Ok(value)
   | Error(error)
 ;
@@ -17,8 +17,8 @@ pub fn is_ok(result) {
 }
 
 test is_ok {
-  is_ok(Ok(1)) |> Assert.true
-  is_ok(Error(1)) |> Assert.false
+  is_ok(Ok(1)) |> Assert:true
+  is_ok(Error(1)) |> Assert:false
 }
 
 pub fn is_error(result) {
@@ -29,8 +29,8 @@ pub fn is_error(result) {
 }
 
 test is_error {
-  is_error(Ok(1)) |> Assert.false
-  is_error(Error(1)) |> Assert.true
+  is_error(Ok(1)) |> Assert:false
+  is_error(Error(1)) |> Assert:true
 }
 
 pub fn map(result, fun) {
@@ -43,10 +43,10 @@ pub fn map(result, fun) {
 test map {
   Ok(1)
     |> map(_, fn(x) { x + 1 })
-    |> Assert.equal(_, Ok(2))
+    |> Assert:equal(_, Ok(2))
   Error(1)
     |> map(_, fn(x) { x + 1 })
-    |> Assert.equal(Error(1))
+    |> Assert:equal(Error(1))
 }
 
 pub fn map_error(result, fun) {
@@ -59,10 +59,10 @@ pub fn map_error(result, fun) {
 test map_error {
   Ok(1)
     |> map_error(_, fn(x) { x + 1 })
-    |> Assert.equal(_, Ok(1))
+    |> Assert:equal(_, Ok(1))
   Error(1)
     |> map_error(_, fn(x) { x + 1 })
-    |> Assert.equal(_, Error(2))
+    |> Assert:equal(_, Error(2))
 }
 
 pub fn flatten(result) {
@@ -74,11 +74,11 @@ pub fn flatten(result) {
 
 test flatten {
   flatten(Ok(Ok(1)))
-    |> Assert.equal(_, Ok(1))
+    |> Assert:equal(_, Ok(1))
   flatten(Ok(Error(1)))
-    |> Assert.equal(_, Error(1))
+    |> Assert:equal(_, Error(1))
   flatten(Error(1))
-    |> Assert.equal(_, Error(1))
+    |> Assert:equal(_, Error(1))
 }
 
 pub fn flat_map(result, fun) {
@@ -90,13 +90,13 @@ pub fn flat_map(result, fun) {
 test flat_map {
   Error(1)
     |> flat_map(_, fn(x) { Ok(x + 1) })
-    |> Assert.equal(_, Error(1))
+    |> Assert:equal(_, Error(1))
   Ok(1)
     |> flat_map(_, fn(x) { Ok(x + 1) })
-    |> Assert.equal(_, Ok(2))
+    |> Assert:equal(_, Ok(2))
   Ok(1)
     |> flat_map(_, fn(_) { Error(1) })
-    |> Assert.equal(_, Error(1))
+    |> Assert:equal(_, Error(1))
 }
 
 pub fn unwrap(result, default) {
@@ -107,6 +107,6 @@ pub fn unwrap(result, default) {
 }
 
 test unwrap {
-  unwrap(Ok(1), 50) |> Assert.equal(_, 1)
-  unwrap(Error("nope"), 50) |> Assert.equal(_, 50)
+  unwrap(Ok(1), 50) |> Assert:equal(_, 1)
+  unwrap(Error("nope"), 50) |> Assert:equal(_, 50)
 }