Version 1.0.0

Author: mrdimosthenis

.github/workflows/test.yml

@@ -1,4 +1,3 @@
-
 name: test
 
 on:
@@ -12,11 +11,12 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2.0.0
-      - uses: erlef/setup-beam@v1.9.0
+      - uses: actions/checkout@v4
+      - uses: erlef/setup-beam@v1
         with:
-          otp-version: "23.2"
-          gleam-version: "0.21.0"
-      - run: gleam format --check src test
+          otp-version: "26.0.2"
+          gleam-version: "1.5.1"
+          rebar3-version: "3"
       - run: gleam deps download
-      - run: gleam test
+      - run: gleam test
+      - run: gleam format --check src test

gleam.toml

@@ -1,5 +1,5 @@
 name = "gleam_zlists"
-version = "0.0.4"
+version = "1.0.0"
 licences = ["Apache-2.0"]
 description = "A library for working with lazy lists in Gleam"
 
@@ -14,8 +14,8 @@ user = "mrdimosthenis"
 repo = "gleam_zlists"
 
 [dependencies]
-gleam_stdlib = "~> 0.21"
-zlists = "~> 0.0"
+gleam_stdlib = "~> 0.40.0"
+zlists = "~> 0.0.4"
 
 [dev-dependencies]
-gleeunit = "~> 0.6"
+gleeunit = "~> 1.2.0"

manifest.toml

@@ -2,12 +2,12 @@
 # You typically do not need to edit this file
 
 packages = [
-  { name = "gleam_stdlib", version = "0.21.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "FB03CD50B477867DA65B1318252ABA02F76175754762D15BF6C792CF5B85BCC4" },
-  { name = "gleeunit", version = "0.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "5BF486C3E135B7F5ED8C054925FC48E5B2C79016A39F416FD8CF2E860520EE55" },
+  { name = "gleam_stdlib", version = "0.40.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "86606B75A600BBD05E539EB59FABC6E307EEEA7B1E5865AFB6D980A93BCB2181" },
+  { name = "gleeunit", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "F7A7228925D3EE7D0813C922E062BFD6D7E9310F0BEE585D3A42F3307E3CFD13" },
   { name = "zlists", version = "0.0.4", build_tools = ["mix", "rebar3"], requirements = [], otp_app = "zlists", source = "hex", outer_checksum = "BABC8B78984E4988DAFEB9E07A77F04D3F8EA208D49E60B6669DA43B0D2C2C4B" },
 ]
 
 [requirements]
-gleam_stdlib = "~> 0.21"
-gleeunit = "~> 0.6"
-zlists = "~> 0.0"
+gleam_stdlib = { version = "~> 0.40.0" }
+gleeunit = { version = "~> 1.2.0" }
+zlists = { version = "~> 0.0.4" }

src/gleam_zlists.gleam

@@ -3,8 +3,8 @@
 //// For more information see [this website](https://github.com/mrdimosthenis/gleam_zlists).
 
 import gleam/bool
+import gleam/iterator.{type Iterator, Done, Next}
 import gleam/result
-import gleam/iterator.{Done, Iterator, Next}
 import gleam_zlists/interface as api
 
 /// A type for representing lazy lists.
@@ -420,6 +420,7 @@ pub fn head(zlist: ZList(t)) -> Result(t, Nil) {
   case ls {
     [] -> Error(Nil)
     [v] -> Ok(v)
+    [v, _, ..] -> Ok(v)
   }
 }
 
@@ -447,7 +448,7 @@ pub fn tail(zlist: ZList(t)) -> Result(ZList(t), Nil) {
     |> to_list
   case ls {
     [] -> Error(Nil)
-    [_] ->
+    [_] | [_, _, ..] ->
       zlist
       |> drop(1)
       |> Ok
@@ -469,11 +470,11 @@ pub fn tail(zlist: ZList(t)) -> Result(ZList(t), Nil) {
 /// ```
 ///
 pub fn uncons(zlist: ZList(t)) -> Result(#(t, ZList(t)), Nil) {
-  case #(head(zlist), tail(zlist)) {
-    #(Ok(hd), Ok(tl)) ->
+  case head(zlist), tail(zlist) {
+    Ok(hd), Ok(tl) ->
       #(hd, tl)
       |> Ok
-    _ -> Error(Nil)
+    _, _ -> Error(Nil)
   }
 }
 
@@ -547,14 +548,11 @@ pub fn all(zlist: ZList(t), fun: fn(t) -> Bool) -> Bool {
 ///
 pub fn any(zlist: ZList(t), fun: fn(t) -> Bool) -> Bool {
   let #(_, zls_b) =
-    split_while(
-      zlist,
-      fn(x) {
-        x
-        |> fun
-        |> bool.negate
-      },
-    )
+    split_while(zlist, fn(x) {
+      x
+      |> fun
+      |> bool.negate
+    })
   zls_b
   |> is_empty
   |> bool.negate
@@ -728,14 +726,11 @@ pub fn with_index(zlist: ZList(t)) -> ZList(#(t, Int)) {
 pub fn unzip(zlist: ZList(#(a, b))) -> #(ZList(a), ZList(b)) {
   zlist
   |> reverse
-  |> reduce(
-    #(new(), new()),
-    fn(it, acc) {
-      let #(x, y) = it
-      let #(acc_xs, acc_ys) = acc
-      #(cons(acc_xs, x), cons(acc_ys, y))
-    },
-  )
+  |> reduce(#(new(), new()), fn(it, acc) {
+    let #(x, y) = it
+    let #(acc_xs, acc_ys) = acc
+    #(cons(acc_xs, x), cons(acc_ys, y))
+  })
 }
 
 /// Returns the sum of all elements. The elements should be `Float` numbers.
@@ -771,16 +766,12 @@ pub fn max(zlist: ZList(Float)) -> Result(Float, Nil) {
   |> uncons
   |> result.map(fn(x) {
     let #(hd, tl) = x
-    reduce(
-      tl,
-      hd,
-      fn(x, acc) {
-        case x >. acc {
-          True -> x
-          False -> acc
-        }
-      },
-    )
+    reduce(tl, hd, fn(x, acc) {
+      case x >. acc {
+        True -> x
+        False -> acc
+      }
+    })
   })
 }
 
@@ -802,16 +793,12 @@ pub fn min(zlist: ZList(Float)) -> Result(Float, Nil) {
   |> uncons
   |> result.map(fn(x) {
     let #(hd, tl) = x
-    reduce(
-      tl,
-      hd,
-      fn(x, acc) {
-        case x <. acc {
-          True -> x
-          False -> acc
-        }
-      },
-    )
+    reduce(tl, hd, fn(x, acc) {
+      case x <. acc {
+        True -> x
+        False -> acc
+      }
+    })
   })
 }
 
@@ -841,15 +828,12 @@ fn recurrent(
   s0: t1,
   rec_fun: fn(t, t1) -> Result(#(t, t1), Nil),
 ) -> ZList(t) {
-  api.new_2(
-    singleton(x0),
-    fn() {
-      case rec_fun(x0, s0) {
-        Ok(#(x1, s1)) -> recurrent(x1, s1, rec_fun)
-        Error(Nil) -> new()
-      }
-    },
-  )
+  api.new_2(singleton(x0), fn() {
+    case rec_fun(x0, s0) {
+      Ok(#(x1, s1)) -> recurrent(x1, s1, rec_fun)
+      Error(Nil) -> new()
+    }
+  })
 }
 
 /// Converts the `iter` into a `ZList`.

src/gleam_zlists/interop.gleam

@@ -1,79 +1,79 @@
-pub external type ZList(a)
+pub type ZList(a)
 
-pub external fn new_1(List(t), fn() -> List(t)) -> ZList(t) =
-  "zlists" "new"
+@external(erlang, "zlists", "new")
+pub fn new_1(x: List(t), y: fn() -> List(t)) -> ZList(t)
 
-pub external fn new_2(ZList(t), fn() -> ZList(t)) -> ZList(t) =
-  "zlists" "new"
+@external(erlang, "zlists", "new")
+pub fn new_2(x: ZList(t), y: fn() -> ZList(t)) -> ZList(t)
 
-pub external fn generate(ZList(t), fn(t) -> ZList(t1)) -> ZList(t1) =
-  "zlists" "generate"
+@external(erlang, "zlists", "generate")
+pub fn generate(x: ZList(t), y: fn(t) -> ZList(t1)) -> ZList(t1)
 
-pub external fn recurrent_2(t, fn(t) -> t) -> ZList(t) =
-  "zlists" "recurrent"
+@external(erlang, "zlists", "recurrent")
+pub fn recurrent_2(x: t, y: fn(t) -> t) -> ZList(t)
 
-pub external fn recurrent_3(t, t1, fn(t, t1) -> #(t, t1)) -> ZList(t) =
-  "zlists" "recurrent"
+@external(erlang, "zlists", "recurrent")
+pub fn recurrent_3(x: t, y: t1, z: fn(t, t1) -> #(t, t1)) -> ZList(t)
 
-pub external fn foreach(fn(t) -> any, ZList(t)) -> Nil =
-  "zlists" "foreach"
+@external(erlang, "zlists", "foreach")
+pub fn foreach(x: fn(t) -> any, y: ZList(t)) -> Nil
 
-pub external fn foldl(fn(t, acc) -> acc, acc, ZList(t)) -> acc =
-  "zlists" "foldl"
+@external(erlang, "zlists", "foldl")
+pub fn foldl(x: fn(t, acc) -> acc, y: acc, z: ZList(t)) -> acc
 
-pub external fn map(fn(a) -> b, ZList(a)) -> ZList(b) =
-  "zlists" "map"
+@external(erlang, "zlists", "map")
+pub fn map(x: fn(a) -> b, y: ZList(a)) -> ZList(b)
 
-pub external fn seq(Int, Int, Int) -> ZList(Int) =
-  "zlists" "seq"
+@external(erlang, "zlists", "seq")
+pub fn seq(x: Int, y: Int, z: Int) -> ZList(Int)
 
-pub external fn dropwhile(fn(t) -> Bool, ZList(t)) -> ZList(t) =
-  "zlists" "dropwhile"
+@external(erlang, "zlists", "dropwhile")
+pub fn dropwhile(x: fn(t) -> Bool, y: ZList(t)) -> ZList(t)
 
-pub external fn drop(Int, ZList(t)) -> ZList(t) =
-  "zlists" "drop"
+@external(erlang, "zlists", "drop")
+pub fn drop(x: Int, y: ZList(t)) -> ZList(t)
 
-pub external fn takewhile(fn(t) -> Bool, ZList(t)) -> ZList(t) =
-  "zlists" "takewhile"
+@external(erlang, "zlists", "takewhile")
+pub fn takewhile(x: fn(t) -> Bool, y: ZList(t)) -> ZList(t)
 
-pub external fn take(Int, ZList(t)) -> ZList(t) =
-  "zlists" "take"
+@external(erlang, "zlists", "take")
+pub fn take(x: Int, y: ZList(t)) -> ZList(t)
 
-pub external fn filter(fn(t) -> Bool, ZList(t)) -> ZList(t) =
-  "zlists" "filter"
+@external(erlang, "zlists", "filter")
+pub fn filter(x: fn(t) -> Bool, y: ZList(t)) -> ZList(t)
 
-pub external fn expand(ZList(t)) -> List(t) =
-  "zlists" "expand"
+@external(erlang, "zlists", "expand")
+pub fn expand(x: ZList(t)) -> List(t)
 
-pub external fn append(ZList(ZList(t))) -> ZList(t) =
-  "zlists" "append"
+@external(erlang, "zlists", "append")
+pub fn append(x: ZList(ZList(t))) -> ZList(t)
 
-pub external fn scroll(Int, ZList(t)) -> #(List(t), ZList(t)) =
-  "zlists" "scroll"
+@external(erlang, "zlists", "scroll")
+pub fn scroll(x: Int, y: ZList(t)) -> #(List(t), ZList(t))
 
-pub external fn merge(ZList(t), ZList(t)) -> ZList(t) =
-  "zlists" "merge"
+@external(erlang, "zlists", "merge")
+pub fn merge(x: ZList(t), y: ZList(t)) -> ZList(t)
 
-pub external fn splitwith(fn(t) -> Bool, ZList(t)) -> #(List(t), ZList(t)) =
-  "zlists" "splitwith"
+@external(erlang, "zlists", "splitwith")
+pub fn splitwith(x: fn(t) -> Bool, y: ZList(t)) -> #(List(t), ZList(t))
 
-pub external fn cartesian(ZList(t), ZList(t)) -> ZList(t) =
-  "zlists" "cartesian"
+@external(erlang, "zlists", "cartesian")
+pub fn cartesian(x: ZList(t), y: ZList(t)) -> ZList(t)
 
-pub external fn zip(ZList(a), ZList(b)) -> ZList(#(a, b)) =
-  "zlists" "zip"
+@external(erlang, "zlists", "zip")
+pub fn zip(x: ZList(a), y: ZList(b)) -> ZList(#(a, b))
 
-pub external fn ziph(ZList(a), ZList(b)) -> ZList(#(a, b)) =
-  "zlists" "ziph"
+@external(erlang, "zlists", "ziph")
+pub fn ziph(x: ZList(a), y: ZList(b)) -> ZList(#(a, b))
 
-pub external fn unique_1(ZList(t)) -> ZList(t) =
-  "zlists" "unique"
+@external(erlang, "zlists", "unique")
+pub fn unique_1(x: ZList(t)) -> ZList(t)
 
-pub external fn unique_2(fn(t, t) -> Bool, ZList(t)) -> ZList(t) =
-  "zlists" "unique"
+@external(erlang, "zlists", "unique")
+pub fn unique_2(x: fn(t, t) -> Bool, y: ZList(t)) -> ZList(t)
 
-pub external fn count(ZList(t)) -> Int =
-  "zlists" "count"
+@external(erlang, "zlists", "count")
+pub fn count(x: ZList(t)) -> Int
 
-pub external fn print(ZList(t)) -> Nil =
-  "zlists" "print"
+@external(erlang, "zlists", "print")
+pub fn print(x: ZList(t)) -> Nil

test/gleam_zlists/gleam_zlists_test.gleam

@@ -1,9 +1,9 @@
-import gleeunit/should
 import gleam/int
-import gleam/string
-import gleam/result
 import gleam/iterator.{Done, Next}
+import gleam/result
+import gleam/string
 import gleam_zlists as zlist
+import gleeunit/should
 
 pub fn append_test() {
   zlist.append(zlist.range(1, 3, 1), zlist.range(4, 6, 1))
@@ -69,14 +69,11 @@ pub fn reduce_test() {
 
   [1, 2, 3]
   |> zlist.of_list
-  |> zlist.reduce(
-    "0",
-    fn(x, acc) {
-      x
-      |> int.to_string
-      |> string.append(acc)
-    },
-  )
+  |> zlist.reduce("0", fn(x, acc) {
+    x
+    |> int.to_string
+    |> string.append(acc)
+  })
   |> should.equal("3210")
 }
 
@@ -701,15 +698,12 @@ pub fn of_iterator_test() {
   |> zlist.to_list
   |> should.equal([1, 2, 3])
 
-  iterator.unfold(
-    100,
-    fn(n) {
-      case n {
-        0 -> Done
-        n -> Next(element: n, accumulator: n - 1)
-      }
-    },
-  )
+  iterator.unfold(100, fn(n) {
+    case n {
+      0 -> Done
+      n -> Next(element: n, accumulator: n - 1)
+    }
+  })
   |> zlist.of_iterator
   |> zlist.take(3)
   |> zlist.to_list