aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Order.gleam98
-rw-r--r--src/bool.gleam (renamed from src/Bool.gleam)34
-rw-r--r--src/foreign.gleam (renamed from src/Foreign.gleam)0
-rw-r--r--src/list.gleam (renamed from src/List.gleam)75
-rw-r--r--src/order.gleam100
-rw-r--r--src/result.gleam (renamed from src/Result.gleam)34
6 files changed, 173 insertions, 168 deletions
diff --git a/src/Order.gleam b/src/Order.gleam
deleted file mode 100644
index b0b43da..0000000
--- a/src/Order.gleam
+++ /dev/null
@@ -1,98 +0,0 @@
-pub enum Order =
- | LT
- | EQ
- | GT
-;
-
-import Order:*
-
-pub fn reverse(order) {
- case order {
- | LT => GT
- | EQ => EQ
- | GT => LT
- }
-}
-
-test reverse {
- reverse(LT) |> Assert:equal(_, GT)
- reverse(EQ) |> Assert:equal(_, EQ)
- reverse(GT) |> Assert:equal(_, LT)
-}
-
-pub fn to_int(order) {
- case order {
- | LT => -1
- | EQ => 0
- | GT => 1
- }
-}
-
-test to_int {
- to_int(LT) |> Assert:equal(_, -1)
- to_int(EQ) |> Assert:equal(_, 0)
- to_int(GT) |> Assert:equal(_, 1)
-}
-
-pub fn compare(a, b) {
- case {a, b} {
- | {LT, LT} => EQ
- | {LT, _} => LT
- | {EQ, EQ} => EQ
- | {GT, GT} => EQ
- | {EQ, GT} => LT
- | _ => GT
- }
-}
-
-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)
-}
-
-pub fn max(a, b) {
- case {a, b} {
- | {GT, _} => GT
- | {EQ, LT} => EQ
- | _ => 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)
-}
-
-pub fn min(a, b) {
- case {a, b} {
- | {LT, _} => LT
- | {EQ, GT} => EQ
- | _ => 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)
-}
diff --git a/src/Bool.gleam b/src/bool.gleam
index 2dfadc3..a4d6878 100644
--- a/src/Bool.gleam
+++ b/src/bool.gleam
@@ -1,4 +1,4 @@
-import Order:Order
+import order:Order
pub enum Bool =
| True
@@ -15,10 +15,10 @@ pub fn not(bool) {
test not {
not(True)
- |> Assert:false
+ |> assert:false
not(False)
- |> Assert:true
+ |> assert:true
}
pub fn compare(a, b) {
@@ -32,16 +32,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) {
@@ -53,16 +53,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) {
@@ -74,16 +74,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) {
@@ -95,8 +95,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/Foreign.gleam b/src/foreign.gleam
index e921ea8..e921ea8 100644
--- a/src/Foreign.gleam
+++ b/src/foreign.gleam
diff --git a/src/List.gleam b/src/list.gleam
index 2656a2e..8c269f9 100644
--- a/src/List.gleam
+++ b/src/list.gleam
@@ -1,5 +1,6 @@
-import Result:Result:*
-import Bool:Bool:*
+import assert
+import result:Result:*
+import bool:Bool:*
pub enum Error =
| Empty
@@ -11,10 +12,10 @@ import Error:*
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.
@@ -22,8 +23,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) {
@@ -31,8 +32,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) {
@@ -44,9 +45,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) {
@@ -58,10 +59,10 @@ pub fn head(list) {
test head {
head([0, 4, 5, 7])
- |> Assert:equal(_, Ok(0))
+ |> assert:equal(_, Ok(0))
head([])
- |> Assert:equal(_, Error(Empty))
+ |> assert:equal(_, Error(Empty))
}
pub fn tail(list) {
@@ -73,13 +74,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(Empty))
+ |> assert:equal(_, Error(Empty))
}
pub fn filter(list, fun) {
@@ -89,19 +90,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) {
@@ -124,11 +125,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) {
@@ -152,11 +153,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) {
@@ -177,10 +178,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) {
@@ -188,8 +189,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() {
@@ -197,7 +198,7 @@ pub fn new() {
}
test new() {
- new() |> Assert:equal(_, [])
+ new() |> assert:equal(_, [])
}
pub fn flatten(lists) {
@@ -206,16 +207,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) {
@@ -235,7 +236,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) {
@@ -248,5 +249,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
new file mode 100644
index 0000000..dbeb8e1
--- /dev/null
+++ b/src/order.gleam
@@ -0,0 +1,100 @@
+import assert
+
+pub enum Order =
+ | LT
+ | EQ
+ | GT
+;
+
+import Order:*
+
+pub fn reverse(order) {
+ case order {
+ | LT => GT
+ | EQ => EQ
+ | GT => LT
+ }
+}
+
+test reverse {
+ reverse(LT) |> assert:equal(_, GT)
+ reverse(EQ) |> assert:equal(_, EQ)
+ reverse(GT) |> assert:equal(_, LT)
+}
+
+pub fn to_int(order) {
+ case order {
+ | LT => -1
+ | EQ => 0
+ | GT => 1
+ }
+}
+
+test to_int {
+ to_int(LT) |> assert:equal(_, -1)
+ to_int(EQ) |> assert:equal(_, 0)
+ to_int(GT) |> assert:equal(_, 1)
+}
+
+pub fn compare(a, b) {
+ case {a, b} {
+ | {LT, LT} => EQ
+ | {LT, _} => LT
+ | {EQ, EQ} => EQ
+ | {GT, GT} => EQ
+ | {EQ, GT} => LT
+ | _ => GT
+ }
+}
+
+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)
+}
+
+pub fn max(a, b) {
+ case {a, b} {
+ | {GT, _} => GT
+ | {EQ, LT} => EQ
+ | _ => 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)
+}
+
+pub fn min(a, b) {
+ case {a, b} {
+ | {LT, _} => LT
+ | {EQ, GT} => EQ
+ | _ => 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)
+}
diff --git a/src/Result.gleam b/src/result.gleam
index 219b446..996d92a 100644
--- a/src/Result.gleam
+++ b/src/result.gleam
@@ -1,3 +1,5 @@
+import assert
+
doc """
Result represents the result of something that may succeed or fail.
`Ok` means it was successful, `Error` means it failed.
@@ -17,8 +19,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 +31,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 +45,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 +61,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 +76,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 +92,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 +109,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)
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-27 18:48:32 +0000