Remove function.rescue function

Closes https://github.com/gleam-lang/gleam/issues/1196

1 files changed, 44 insertions, 64 deletions

diff --git a/src/gleam/function.gleam b/src/gleam/function.gleam
index 937a9bc..8010639 100644
--- a/src/gleam/function.gleam
+++ b/src/gleam/function.gleam
@@ -1,73 +1,53 @@
-if erlang {
-  import gleam/dynamic.{Dynamic}
-
-  /// Takes two functions and chains them together to form one function that takes
-  /// the input from the first and returns the output of the second.
-  ///
-  pub fn compose(fun1: fn(a) -> b, fun2: fn(b) -> c) -> fn(a) -> c {
-    fn(a) { fun2(fun1(a)) }
-  }
-
-  /// Takes a function with arity two
-  /// and returns a curried equivalent.
-  /// fn(a, b) -> c becomes fn(a) -> fn(b) -> c
-  pub fn curry2(fun: fn(a, b) -> value) {
-    fn(a) { fn(b) { fun(a, b) } }
-  }
-
-  /// Takes a function with arity three
-  /// and returns a curried equivalent.
-  /// fn(a, b, c) -> d becomes fn(a) -> fn(b) -> fn(c) -> d
-  pub fn curry3(fun: fn(a, b, c) -> value) {
-    fn(a) { fn(b) { fn(c) { fun(a, b, c) } } }
-  }
+/// Takes two functions and chains them together to form one function that takes
+/// the input from the first and returns the output of the second.
+///
+pub fn compose(fun1: fn(a) -> b, fun2: fn(b) -> c) -> fn(a) -> c {
+  fn(a) { fun2(fun1(a)) }
+}
 
-  /// Takes a function with arity four
-  /// and returns a curried equivalent.
-  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 arity two
+/// and returns a curried equivalent.
+/// fn(a, b) -> c becomes fn(a) -> fn(b) -> c
+pub fn curry2(fun: fn(a, b) -> value) {
+  fn(a) { fn(b) { fun(a, b) } }
+}
 
-  /// Takes a function with arity five
-  /// and returns a curried equivalent.
-  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 arity three
+/// and returns a curried equivalent.
+/// fn(a, b, c) -> d becomes fn(a) -> fn(b) -> fn(c) -> d
+pub fn curry3(fun: fn(a, b, c) -> value) {
+  fn(a) { fn(b) { fn(c) { fun(a, b, c) } } }
+}
 
-  /// Takes a function with arity six
-  /// and returns a curried equivalent.
-  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) } } } } }
-    }
-  }
+/// Takes a function with arity four
+/// and returns a curried equivalent.
+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 that takes two arguments and returns a new function that
-  /// takes the same two arguments, but in reverse order.
-  ///
-  pub fn flip(fun: fn(a, b) -> c) -> fn(b, a) -> c {
-    fn(b, a) { fun(a, b) }
-  }
+/// Takes a function with arity five
+/// and returns a curried equivalent.
+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) } } } } }
+}
 
-  /// A function that always returns its input value.
-  ///
-  pub fn identity(x: a) -> a {
-    x
+/// Takes a function with arity six
+/// and returns a curried equivalent.
+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) } } } } }
   }
+}
 
-  pub type Exception {
-    Exited(Dynamic)
-    Thrown(Dynamic)
-    Errored(Dynamic)
-  }
+/// Takes a function that takes two arguments and returns a new function that
+/// takes the same two arguments, but in reverse order.
+///
+pub fn flip(fun: fn(a, b) -> c) -> fn(b, a) -> c {
+  fn(b, a) { fun(a, b) }
+}
 
-  /// Gleam doesn't offer any way to raise exceptions, but they may still occur
-  /// due to bugs when working with unsafe code, such as when calling Erlang
-  /// function.
-  ///
-  /// This function will catch any error thrown and convert it into a result
-  /// rather than crashing the process.
-  ///
-  pub external fn rescue(fn() -> a) -> Result(a, Exception) =
-    "gleam_stdlib" "rescue"
+/// A function that always returns its input value.
+///
+pub fn identity(x: a) -> a {
+  x
 }