In F#, you can define a custom exception type by creating a type that inherit from System.Exception or using the lightweight exception syntax to define them with the same syntax as discriminated unions.
exception MyExceptionB of string
let exThrower (isA : bool option) =
match isA with
| Some(true) -> raise MyExceptionA
| Some(false) -> raise <| MyExceptionB("Blah Blah")
| _ -> raise <| new System.Exception()
| _ -> failwith "Not a valid input"
Erlang also has a number of different exception types, the most common ways to raise an exception in Erlang is via:
- error(Reason) – terminates the current process and includes a stack trace.
- exit(Reason) – similar to errors, but does not return the stack trace.
- throw(Reason) – throws exceptions that the caller can be expected to handle, also used as a way to return from deep recursion.
1> throw("Blah Blah").
** exception throw: "Blah Blah"
** exception error: boo
** exception exit: foo
In F#, you can implement a try-catch block using the try-with keywords, and it’s really easy to use pattern matching to make handling multiple types of exceptions really easy.
In Erlang, the syntax is surprisingly similar:
Another thing to keep in mind is that whilst F# has try-with and try-finally blocks there is no equivalent of C#’s try-catch-finally block. In Erlang the try-catch-finally block looks like this:
black_knight(Attack) when is_function(Attack, 0) –>
try Attack() of
_ -> "None shall pass."
throw:slice -> "It is but a scratch.";
error:cut_arm -> "I’ve had worse.";
exit: cut_leg -> "Come on you pansy!";
_:_ -> "Just a flesh wound."
io:format("Attack finished…~n", )
Subscribe to my newsletter and get new contents delivered straight to your inbox :-)