v2.0.0

Author: lpil

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v2.0.0 - 2024-02-17
+
+- The `rescue` function now indicated whether the exception was an error, a
+  throw, or an exit.
+
 ## v1.1.1 - 2024-01-16
 
 - Relaxed the version constraint for `gleam_stdlib` to permit 1.x or 0.x

gleam.toml

@@ -1,5 +1,5 @@
 name = "exception"
-version = "1.1.1"
+version = "2.0.0"
 gleam = ">= 0.32.0"
 description = "A tiny package for dealing with exceptions"
 licences = ["Apache-2.0"]

src/exception.gleam

@@ -1,8 +1,21 @@
 import gleam/dynamic.{type Dynamic}
 
-// TODO: implement 
-// TODO: test 
-// TODO: document
+pub type Exception {
+  /// An error was raised.
+  /// On Erlang this would be caused by calling the `erlang:error/1` function,
+  /// or some other runtime error.
+  /// On JavaScript this would be caused by throwing an `Error` object.
+  Errored(Dynamic)
+  /// A value was thrown.
+  /// On Erlang this would be caused by calling the `erlang:throw/1` function.
+  /// On JavaScript this would be caused by throwing any non-`Error` value.
+  Thrown(Dynamic)
+  /// A process exited.
+  /// On Erlang this would be caused by calling the `erlang:exit/1` function.
+  /// On JavaScript this variant is not used.
+  Exited(Dynamic)
+}
+
 /// This function will catch any crash and convert it into a result rather than
 /// crashing the process.
 ///
@@ -13,10 +26,8 @@ import gleam/dynamic.{type Dynamic}
 ///
 @external(erlang, "exception_ffi", "rescue")
 @external(javascript, "./exception_ffi.mjs", "rescue")
-pub fn rescue(body: fn() -> a) -> Result(a, Dynamic)
+pub fn rescue(body: fn() -> a) -> Result(a, Exception)
 
-// TODO: implement 
-// TODO: test 
 /// This function will run a cleanup function after the given body function, even
 /// if the body function crashes.
 ///

src/exception_ffi.erl

@@ -4,7 +4,10 @@
 
 rescue(F) ->
     try {ok, F()}
-    catch Tag:Term -> {error, {Tag, Term}}
+    catch
+      error:Term -> {error, {errored, Term}};
+      throw:Term -> {error, {thrown, Term}};
+      exit:Term -> {error, {exited, Term}}
     end.
 
 defer(Cleanup, Body) ->

src/exception_ffi.mjs

@@ -1,10 +1,15 @@
 import { Ok, Error as GError } from "./gleam.mjs";
+import { Errored, Thrown } from "./exception.mjs";
 
 export function rescue(f) {
   try {
     return new Ok(f());
   } catch (e) {
-    return new GError(e);
+    if (e instanceof Error) {
+      return new GError(new Errored(e));
+    } else {
+      return new GError(new Thrown(e));
+    }
   }
 }
 

test/exception_test.gleam

@@ -10,8 +10,26 @@ pub fn rescue_ok_test() {
   let assert Ok(1) = exception.rescue(fn() { 1 })
 }
 
-pub fn rescue_error_test() {
-  let assert Error(_) = exception.rescue(fn() { panic })
+pub fn rescue_errored_test() {
+  let assert Error(exception.Errored(_)) = exception.rescue(fn() { panic })
+}
+
+@external(erlang, "erlang", "throw")
+@external(javascript, "./exception_test_ffi.mjs", "throw_")
+fn throw(a: whatever) -> Nil
+
+pub fn rescue_thrown_test() {
+  let assert Error(exception.Thrown(_)) =
+    exception.rescue(fn() { throw("123") })
+}
+
+@external(erlang, "erlang", "exit")
+@external(javascript, "./exception_test_ffi.mjs", "throw_")
+fn exit(a: whatever) -> Nil
+
+@target(erlang)
+pub fn rescue_exited_test() {
+  let assert Error(exception.Exited(_)) = exception.rescue(fn() { exit("123") })
 }
 
 pub fn defer_ok_test() {

test/exception_test_ffi.mjs

@@ -0,0 +1,3 @@
+export function throw_(x) {
+  throw x;
+}