The OpenD Programming Language

assumeWontThrow

Wraps a possibly-throwing expression in a nothrow wrapper so that it can be called by a nothrow function.

This wrapper function documents commitment on the part of the caller that the appropriate steps have been taken to avoid whatever conditions may trigger an exception during the evaluation of expr. If it turns out that the expression does throw at runtime, the wrapper will throw an AssertError.

(Note that Throwable objects such as AssertError that do not subclass Exception may be thrown even from nothrow functions, since they are considered to be serious runtime problems that cannot be recovered from.)

nothrow
T
assumeWontThrow
(
T
)
(
lazy T expr
,
string msg = null
,
string file = __FILE__
,
size_t line = __LINE__
)

Parameters

expr T

The expression asserted not to throw.

msg string

The message to include in the AssertError if the assumption turns out to be false.

file string

The source file name of the caller.

line size_t

The line number of the caller.

Return Value

Type: T

The value of expr, if any.

Examples

import std.math.algebraic : sqrt;

// This function may throw.
int squareRoot(int x)
{
    if (x < 0)
        throw new Exception("Tried to take root of negative number");
    return cast(int) sqrt(cast(double) x);
}

// This function never throws.
int computeLength(int x, int y) nothrow
{
    // Since x*x + y*y is always positive, we can safely assume squareRoot
    // won't throw, and use it to implement this nothrow function. If it
    // does throw (e.g., if x*x + y*y overflows a 32-bit value), then the
    // program will terminate.
    return assumeWontThrow(squareRoot(x*x + y*y));
}

assert(computeLength(3, 4) == 5);

Meta