diff options
| -rw-r--r-- | CHANGELOG.md | 4 | ||||
| -rw-r--r-- | src/gleam/function.gleam | 69 |
2 files changed, 9 insertions, 64 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md index 04a2e34..0106440 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## Unreleased + +- The `function.curry*` functions have been deprecated. + ## v0.39.0 - 2024-07-09 - Fixed `list.window` entering an endless recursive loop for `n` = 0. diff --git a/src/gleam/function.gleam b/src/gleam/function.gleam index 5ec3bc6..1178f1e 100644 --- a/src/gleam/function.gleam +++ b/src/gleam/function.gleam @@ -3,86 +3,27 @@ pub fn compose(fun1: fn(a) -> b, fun2: fn(b) -> c) -> fn(a) -> c { fn(a) { fun2(fun1(a)) } } -/// Takes a function with `2` arguments (an arity of `2`), and returns the -/// curried equivalent. -/// -/// `fn(a, b) -> c` becomes `fn(a) -> fn(b) -> c`. -/// -/// ## Examples -/// -/// *Currying* creates a new function that is identical to the given function -/// except that arguments must now be supplied one by one over several function -/// calls. It thus is the process of taking a function with `n` arguments -/// and producing a sequence of `n` single-argument functions. Given: -/// -/// ```gleam -/// fn my_fun(i: Int, s: String) -> String { ... } -/// ``` -/// -/// …calling `curry2(my_fun)` would return the curried equivalent, like so: -/// -/// ```gleam -/// curry2(my_fun) -/// // fn(Int) -> fn(String) -> String -/// ``` -/// -/// Currying is useful when you want to partially apply a function with -/// some arguments and then pass it somewhere else, for example: -/// -/// ```gleam -/// import gleam/list -/// -/// let multiply = curry2(fn(x, y) { x * y }) -/// list.map([1, 2, 3], multiply(2)) -/// // -> [2, 4, 6] -/// ``` -/// +@deprecated("Use the anonymous function syntax instead") pub fn curry2(fun: fn(a, b) -> value) { fn(a) { fn(b) { fun(a, b) } } } -/// Takes a function with `3` arguments (an arity of `3`), and returns the -/// curried equivalent. -/// -/// `fn(a, b, c) -> d` becomes `fn(a) -> fn(b) -> fn(c) -> d`. -/// -/// See [`curry2`](#curry2) for a detailed explanation. -/// +@deprecated("Use the anonymous function syntax instead") pub fn curry3(fun: fn(a, b, c) -> value) { fn(a) { fn(b) { fn(c) { fun(a, b, c) } } } } -/// Takes a function with `4` arguments (an arity of `4`), and returns the -/// curried equivalent. -/// -/// `fn(a, b, c, d) -> e` becomes `fn(a) -> fn(b) -> fn(c) -> fn(d) -> e`. -/// -/// See [`curry2`](#curry2) for a detailed explanation. -/// +@deprecated("Use the anonymous function syntax instead") pub fn curry4(fun: fn(a, b, c, d) -> value) { fn(a) { fn(b) { fn(c) { fn(d) { fun(a, b, c, d) } } } } } -/// Takes a function with `5` arguments (an arity of `5`), and returns the -/// curried equivalent. -/// -/// `fn(a, b, c, d, e) -> f` becomes -/// `fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> f`. -/// -/// See [`curry2`](#curry2) for a detailed explanation. -/// +@deprecated("Use the anonymous function syntax instead") pub fn curry5(fun: fn(a, b, c, d, e) -> value) { fn(a) { fn(b) { fn(c) { fn(d) { fn(e) { fun(a, b, c, d, e) } } } } } } -/// Takes a function with `6` arguments (an arity of `6`), and returns the -/// curried equivalent. -/// -/// `fn(a, b, c, d, e, f) -> g` becomes -/// `fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> fn(f) -> g`. -/// -/// See [`curry2`](#curry2) for a detailed explanation. -/// +@deprecated("Use the anonymous function syntax instead") pub fn curry6(fun: fn(a, b, c, d, e, f) -> value) { fn(a) { fn(b) { fn(c) { fn(d) { fn(e) { fn(f) { fun(a, b, c, d, e, f) } } } } } |