No curry

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) } } } } }