Menu
Search

API Documentation

version 2.109.1

overview

View source code
Display the source code in std/exception.d from which this page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

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

NameDescription
E The type of Throwables 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));

Authors

Andrei Alexandrescu and Jonathan M Davis

License

Boost License 1.0