Function std.exception.ifThrown
ML-style functional exception handling. Runs the supplied expression and
returns its result. If the expression throws a Throwable
, runs the
supplied error handler instead and return its result. The error handler's
type must be the same as the expression's type.
CommonType!(T1,T2) ifThrown(E, T1, T2)
(
scope lazy T1 expression,
scope lazy T2 errorHandler
);
CommonType!(T1,T2) ifThrown(E, T1, T2)
(
scope lazy T1 expression,
scope T2 delegate(E) errorHandler
);
CommonType!(T1,T2) ifThrown(T1, T2)
(
scope lazy T1 expression,
scope T2 delegate(Exception) errorHandler
);
Parameters
Name | Description |
---|---|
E | The type of Throwable s to catch. Defaults to Exception |
T1 | The type of the expression. |
T2 | The return type of the error handler. |
expression | The expression to run and return its result. |
errorHandler | The handler to run if the expression throwed. |
Returns
expression, if it does not throw. Otherwise, returns the result of errorHandler.
Example
Revert to a default value upon an error:
import std .conv : to;
writeln("x" .to!int .ifThrown(0)); // 0
Example
Chain multiple calls to ifThrown, each capturing errors from the entire preceding expression.
import std .conv : ConvException, to;
string s = "true";
assert(s .to!int .ifThrown(cast(int) s .to!double)
.ifThrown(cast(int) s .to!bool) == 1);
s = "2.0";
assert(s .to!int .ifThrown(cast(int) s .to!double)
.ifThrown(cast(int) s .to!bool) == 2);
// Respond differently to different types of errors
alias orFallback = (lazy a) => a .ifThrown!ConvException("not a number")
.ifThrown!Exception("number too small");
writeln(orFallback(enforce("x" .to!int < 1) .to!string)); // "not a number"
writeln(orFallback(enforce("2" .to!int < 1) .to!string)); // "number too small"
Example
The expression and the errorHandler must have a common type they can both be implicitly casted to, and that type will be the type of the compound expression.
// null and new Object have a common type(Object).
static assert(is(typeof(null .ifThrown(new Object())) == Object));
static assert(is(typeof((new Object()) .ifThrown(null)) == Object));
// 1 and new Object do not have a common type.
static assert(!__traits(compiles, 1 .ifThrown(new Object())));
static assert(!__traits(compiles, (new Object()) .ifThrown(1)));
Example
Use a lambda to get the thrown object.
import std .format : format;
// "std.format.FormatException"
writeln("%s" .format .ifThrown!Exception(e => e .classinfo .name));