Blog

This topic is about Elixir – Errors Handling.

Elixir has three error mechanisms: errors, throws and exits. Let us explore each mechanism in detail.

Error

Errors (or exceptions) are used when exceptional things happen in the code. A sample error can be retrieved by trying to add a number into a string −

IO.puts(1 + "Hello")

When the above program is run, it produces the following error −

** (ArithmeticError) bad argument in arithmetic expression
   :erlang.+(1, "Hello")

This was a sample inbuilt error.

Raising Errors

We can raise errors using the raise functions. Let us consider an example to understand the same −

#Runtime Error with just a message
raise "oops"  # ** (RuntimeError) oops

Other errors can be raised with raise/2 passing the error name and a list of keyword arguments

#Other error type with a message
raise ArgumentError, message: "invalid argument foo"

You can also define your own errors and raise those. Consider the following example −

defmodule MyError do
   defexception message: "default message"
end

raise MyError  # Raises error with default message
raise MyError, message: "custom message"  # Raises error with custom message

Rescuing Errors

We do not want our programs to abruptly quit but rather the errors need to be handled carefully. For this we use error handling. We rescue errors using the try/rescue construct. Let us consider the following example to understand the same −Live Demo

err = try do
   raise "oops"
rescue
   e in RuntimeError -> e
end

IO.puts(err.message)

When the above program is run, it produces the following result −

oops

We have handled errors in the rescue statement using pattern matching. If we do not have any use of the error, and just want to use it for identification purposes, we can also use the form −

err = try do
   1 + "Hello"
rescue
   RuntimeError -> "You've got a runtime error!"
   ArithmeticError -> "You've got a Argument error!"
end

IO.puts(err)

When running above program, it produces the following result −

You've got a Argument error!

NOTE − Most functions in the Elixir standard library are implemented twice, once returning tuples and the other time raising errors. For example, the File.read and the File.read! functions. The first one returned a tuple if the file was read successfully and if an error was encountered, this tuple was used to give the reason for the error. The second one raised an error if an error was encountered.

If we use the first function approach, then we need to use case for pattern matching the error and take action according to that. In the second case, we use the try rescue approach for error prone code and handle errors accordingly.

Throws

In Elixir, a value can be thrown and later be caught. Throw and Catch are reserved for situations where it is not possible to retrieve a value unless by using throw and catch.

The instances are quite uncommon in practice except when interfacing with libraries. For example, let us now assume that the Enum module did not provide any API for finding a value and that we needed to find the first multiple of 13 in a list of numbers −

val = try do
   Enum.each 20..100, fn(x) ->
      if rem(x, 13) == 0, do: throw(x)
   end
   "Got nothing"
catch
   x -> "Got #{x}"
end

IO.puts(val)

When the above program is run, it produces the following result −

Got 26

Exit

When a process dies of “natural causes” (for example, unhandled exceptions), it sends an exit signal. A process can also die by explicitly sending an exit signal. Let us consider the following example −

spawn_link fn -> exit(1) end

In the example above, the linked process died by sending an exit signal with value of 1. Note that exit can also be “caught” using try/catch. For example −

val = try do
   exit "I am exiting"
catch
   :exit, _ -> "not really"
end

IO.puts(val)

When the above program is run, it produces the following result −

not really

After

Sometimes it is necessary to ensure that a resource is cleaned up after some action that can potentially raise an error. The try/after construct allows you to do that. For example, we can open a file and use an after clause to close it–even if something goes wrong.

{:ok, file} = File.open "sample", [:utf8, :write]
try do
   IO.write file, "olá"
   raise "oops, something went wrong"
after
   File.close(file)
end

When we run this program, it will give us an error. But the after statement will ensure that the file descriptor is closed upon any such event.

In this topic we learned about Elixir – Errors Handling. To know more, Click Here.