Erlang and OTP in Action.pdf - Synrc

58
The stack trace is a list, in reverse order (last call first), of the calls nearest the top of the
stack when the exception occurred. Each function is represented as {Module, Function,
Args}, where Module and Function are atoms, and Args is either the arity of the function, or
the actual list of arguments to the call, depending on what information was available at the
time. Typically, only the topmost call might have an argument list.
Note that if you call erlang:get_stacktrace() and get an empty list, it simply means that
no exception has been caught by this process yet.
2.8.6 – Re-throwing
It might happen that you need to examine an exception more closely before you decide
whether to catch it or not. Although this is unusual, you can then catch it first and re-throw it
if necessary, using the built-in function erlang:raise(Class, Reason, Stacktrace). Here, Class
must be one of error, exit, or throw, and Stacktrace should be what you got from
erlang:get_stacktrace(). For example:
try
do_something(…)
catch
Class:Reason ->
Trace = erlang:get_stacktrace(),
case analyze_exc(Class, Reason) of
true -> handle_exc(Class, Reason, Trace),
false -> erlang:raise(Class, Reason, Trace)
end
end
In the above, we catch any exception, analyze it, and either handle it ourselves or rethrow
it. It is however both messy and inefficient (since it requires creating the symbolic
stack trace as a list of tuples) and should only be done if you see no better solution.
2.8.7 – Plain old catch
Before try–expressions were added to the language, there was just catch. You’ll see a lot
of this in older code, since it was the only way of handling exceptions. It works like this:
“catch Expression” will evaluate Expression (which can be any expression), and if it
produces a result (i.e., doesn’t throw an exception), you’ll simply get that result. Otherwise,
if there is an exception, it will be caught and presented as the result of the catch, using
different conventions depending on the exception class. This shell dialog demonstrates the
different cases:
1> catch throw(foo).
foo
2> catch exit(foo).
{'EXIT',foo}
3> catch foo=bar.
{'EXIT',{{badmatch,bar},[{erl_eval,expr,3}]}}
©Manning Publications Co. Please post comments or corrections to the Author Online forum:
http://www.manning-sandbox.com/forum.jspaforumID=454