v0.58.0

Author: lpil

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v0.58.0 - 2025-03-23
+
+- The deprecated `pop` and `pop_map` functions have been removed from the
+  `list` module.
+
 ## v0.57.0 - 2025-03-11
 
 - The minimum supported Gleam version has been increased to 1.9.0.

gleam.toml

@@ -1,5 +1,5 @@
 name = "gleam_stdlib"
-version = "0.57.0"
+version = "0.58.0"
 gleam = ">= 1.9.0"
 licences = ["Apache-2.0"]
 description = "A standard library for the Gleam programming language"

src/gleam/function.gleam

@@ -1,20 +1,12 @@
-/// Takes a function that takes two arguments and returns a new function that
-/// takes the same two arguments, but in reverse order.
-///
-@deprecated("This function has been deprecated. Use a function literal instead: `fn(a, b) { fun(b, a) }`")
-pub fn flip(fun: fn(a, b) -> c) -> fn(b, a) -> c {
-  fn(b, a) { fun(a, b) }
-}
-
 /// Takes a single argument and always returns its input value.
 ///
 pub fn identity(x: a) -> a {
   x
 }
 
-/// Takes an argument and a single function,
-/// calls that function with that argument
-/// and returns that argument instead of the function return value.
+/// Takes an argument and a single function, calls that function with that
+/// argument and returns that argument instead of the function return value.
+///
 /// Useful for running synchronous side effects in a pipeline.
 ///
 pub fn tap(arg: a, effect: fn(a) -> b) -> a {

src/gleam/list.gleam

@@ -1636,91 +1636,6 @@ pub fn key_filter(
   })
 }
 
-/// Removes the first element in a given list for which the predicate function returns `True`.
-///
-/// Returns `Error(Nil)` if no such element is found.
-///
-/// ## Examples
-///
-/// ```gleam
-/// pop([1, 2, 3], fn(x) { x > 2 })
-/// // -> Ok(#(3, [1, 2]))
-/// ```
-///
-/// ```gleam
-/// pop([1, 2, 3], fn(x) { x > 4 })
-/// // -> Error(Nil)
-/// ```
-///
-/// ```gleam
-/// pop([], fn(_) { True })
-/// // -> Error(Nil)
-/// ```
-///
-@deprecated("This function will be removed in the next gleam_stdlib version")
-pub fn pop(
-  in list: List(a),
-  one_that is_desired: fn(a) -> Bool,
-) -> Result(#(a, List(a)), Nil) {
-  pop_loop(list, is_desired, [])
-}
-
-fn pop_loop(haystack, predicate, checked) {
-  case haystack {
-    [] -> Error(Nil)
-    [first, ..rest] ->
-      case predicate(first) {
-        True -> Ok(#(first, append(reverse(checked), rest)))
-        False -> pop_loop(rest, predicate, [first, ..checked])
-      }
-  }
-}
-
-/// Removes the first element in a given list for which the given function returns
-/// `Ok(new_value)`, then returns the wrapped `new_value` as well as list with the value removed.
-///
-/// Returns `Error(Nil)` if no such element is found.
-///
-/// ## Examples
-///
-/// ```gleam
-/// pop_map([[], [2], [3]], first)
-/// // -> Ok(#(2, [[], [3]]))
-/// ```
-///
-/// ```gleam
-/// pop_map([[], []], first)
-/// // -> Error(Nil)
-/// ```
-///
-/// ```gleam
-/// pop_map([], first)
-/// // -> Error(Nil)
-/// ```
-///
-@deprecated("This function will be removed in the next gleam_stdlib version")
-pub fn pop_map(
-  in haystack: List(a),
-  one_that is_desired: fn(a) -> Result(b, c),
-) -> Result(#(b, List(a)), Nil) {
-  pop_map_loop(haystack, is_desired, [])
-}
-
-fn pop_map_loop(
-  list: List(a),
-  mapper: fn(a) -> Result(b, e),
-  checked: List(a),
-) -> Result(#(b, List(a)), Nil) {
-  case list {
-    [] -> Error(Nil)
-    [first, ..rest] ->
-      case mapper(first) {
-        Ok(mapped) -> Ok(#(mapped, append(reverse(checked), rest)))
-        Error(_) -> pop_map_loop(rest, mapper, [first, ..checked])
-      }
-  }
-}
-
 /// Given a list of 2-element tuples, finds the first tuple that has a given
 /// key as the first element. This function will return the second element
 /// of the found tuple and list with tuple removed.

test/gleam/function_test.gleam

@@ -1,26 +1,7 @@
 import gleam/function
-import gleam/int
 import gleam/should
 import gleam/string
 
-pub fn flip_test() {
-  let fun = fn(s: String, i: Int) {
-    s
-    |> string.append("String: '", _)
-    |> string.append("', Int: '")
-    |> string.append(int.to_string(i))
-    |> string.append("'")
-  }
-
-  let flipped_fun = function.flip(fun)
-
-  fun("Bob", 1)
-  |> should.equal("String: 'Bob', Int: '1'")
-
-  flipped_fun(2, "Alice")
-  |> should.equal("String: 'Alice', Int: '2'")
-}
-
 pub fn identity_test() {
   1
   |> function.identity

test/gleam/list_test.gleam

@@ -828,41 +828,6 @@ pub fn key_filter_test() {
   |> should.equal([])
 }
 
-pub fn pop_test() {
-  [1, 2, 3]
-  |> list.pop(fn(x) { x > 2 })
-  |> should.equal(Ok(#(3, [1, 2])))
-
-  [1, 2, 3]
-  |> list.pop(fn(x) { x > 4 })
-  |> should.equal(Error(Nil))
-
-  []
-  |> list.pop(fn(_x) { True })
-  |> should.equal(Error(Nil))
-
-  // TCO test
-  list.repeat(0, recursion_test_cycles + 10)
-  |> list.pop(fn(x) { x > recursion_test_cycles + 1 })
-}
-
-pub fn pop_map_test() {
-  let get = fn(x) {
-    case x > 0 {
-      True -> Ok(x * 2)
-      False -> Error(Nil)
-    }
-  }
-  list.pop_map([0, 2, 3], get)
-  |> should.equal(Ok(#(4, [0, 3])))
-
-  list.pop_map([0, -1], get)
-  |> should.equal(Error(Nil))
-
-  list.pop_map([], get)
-  |> should.equal(Error(Nil))
-}
-
 pub fn key_pop_test() {
   list.key_pop([#("a", 0), #("b", 1)], "a")
   |> should.equal(Ok(#(0, [#("b", 1)])))