Asserts that the given expression does not throw the given type of Throwable. If a Throwable of the given type is thrown, it is caught and does not escape  assertNotThrown. Rather, an AssertError is thrown. However, any other Throwables will escape.

    assertNotThrown!StringException(enforceEx!StringException(true, "Error!"));

    //Exception is the default.

    assertNotThrown(enforceEx!StringException(true, "Error!"));

    assert(collectExceptionMsg!AssertError(assertNotThrown!StringException(
               enforceEx!StringException(false, "Error!"))) ==
           `assertNotThrown failed: StringException was thrown: Error!`);

Asserts that the given expression throws the given type of Throwable. The Throwable is caught and does not escape  assertThrown. However, any other Throwables will escape, and if no Throwable of the given type is thrown, then an AssertError is thrown.

    assertThrown!StringException(enforceEx!StringException(false, "Error!"));

    //Exception is the default.

    assertThrown(enforceEx!StringException(false, "Error!"));

    assert(collectExceptionMsg!AssertError(assertThrown!StringException(
               enforceEx!StringException(true, "Error!"))) ==
           `assertThrown failed: No StringException was thrown.`);

If !!value is true, value is returned. Otherwise, new Exception(msg) is thrown.

auto f = enforce(fopen("data.txt"));
auto line = readln(f);
enforce(line.length, "Expected a non-empty line.");

Scheduled for deprecation in January 2013. If passing the file or line number explicitly, please use the version of  enforce which takes them as function arguments. Taking them as template arguments causes unnecessary template bloat.

If !!value is true, value is returned. Otherwise, the given delegate is called.

The whole safety and purity are inferred from Dg's safety and purity.

If !!value is true, value is returned. Otherwise, ex is thrown.

auto f = enforce(fopen("data.txt"));
auto line = readln(f);
enforce(line.length, new IOException); // expect a non-empty line

If !!value is true, value is returned. Otherwise, new ErrnoException(msg) is thrown. ErrnoException assumes that the last operation set errno to an error code.

auto f = errnoEnforce(fopen("data.txt"));
auto line = readln(f);
enforce(line.length); // expect a non-empty line

If !!value is true, value is returned. Otherwise, new E(msg, file, line) is thrown. Or if E doesn't take a message and can be constructed with new E(file, line), then new E(file, line) will be thrown.

auto f = enforceEx!FileMissingException(fopen("data.txt"));
auto line = readln(f);
enforceEx!DataCorruptionException(line.length);

Catches and returns the exception thrown from the given expression. If no exception is thrown, then null is returned and result is set to the result of the expression.

Note that while  collectException can be used to collect any Throwable and not just Exceptions, it is generally ill-advised to catch anything that is neither an Exception nor a type derived from Exception. So, do not use  collectException to collect non-Exceptions unless you're sure that that's what you really want to do.

    int b;
    int foo() { throw new Exception("blah"); }
    assert(collectException(foo(), b));

    int[] a = new int[3];
    import core.exception : RangeError;
    assert(collectException!RangeError(a[4], b));

Catches and returns the exception thrown from the given expression. If no exception is thrown, then null is returned. E can be void.

Note that while  collectException can be used to collect any Throwable and not just Exceptions, it is generally ill-advised to catch anything that is neither an Exception nor a type derived from Exception. So, do not use  collectException to collect non-Exceptions unless you're sure that that's what you really want to do.

Catches the exception thrown from the given expression and returns the msg property of that exception. If no exception is thrown, then null is returned. E can be void.

If an exception is thrown but it has an empty message, then emptyExceptionMsg is returned.

Note that while  collectExceptionMsg can be used to collect any Throwable and not just Exceptions, it is generally ill-advised to catch anything that is neither an Exception nor a type derived from Exception. So, do not use  collectExceptionMsg to collect non-Exceptions unless you're sure that that's what you really want to do.

    void throwFunc() { throw new Exception("My Message."); }
    assert(collectExceptionMsg(throwFunc()) == "My Message.");

    void nothrowFunc() {}
    assert(collectExceptionMsg(nothrowFunc()) is null);

    void throwEmptyFunc() { throw new Exception(""); }
    assert(collectExceptionMsg(throwEmptyFunc()) == emptyExceptionMsg);

Value that collectExceptionMsg returns when it catches an exception with an empty exception message.

Casts a mutable array to an immutable array in an idiomatic manner. Technically,  assumeUnique just inserts a cast, but its name documents assumptions on the part of the caller.  assumeUnique(arr) should only be called when there are no more active mutable aliases to elements of arr. To strenghten this assumption,  assumeUnique(arr) also clears arr before returning. Essentially  assumeUnique(arr) indicates commitment from the caller that there is no more mutable access to any of arr's elements (transitively), and that all future accesses will be done through the immutable array returned by  assumeUnique.

Typically,  assumeUnique is used to return arrays from functions that have allocated and built them.

string letters()
{
  char[] result = new char['z' - 'a' + 1];
  foreach (i, ref e; result)
  {
    e = 'a' + i;
  }
  return assumeUnique(result);
}

private char[] buffer;
string letters(char first, char last)
{
  if (first >= last) return null; // fine

  auto sneaky = buffer;
  sneaky.length = last - first + 1;
  foreach (i, ref e; sneaky)
  {
    e = 'a' + i;
  }
  return assumeUnique(sneaky); // BAD

}

return to!(string)(sneaky); // not that sneaky anymore

Returns true if source's representation embeds a pointer that points to target's representation or somewhere inside it.

If source is or contains a dynamic array, then, then  pointsTo will check if there is overlap between the dynamic array and target's representation.

If source is or contains a union, then every member of the union is checked for embedded pointers. This may lead to false positives, depending on which should be considered the "active" member of the union.

If source is a class, then  pointsTo will handle it as a pointer.

If target is a pointer, a dynamic array or a class, then  pointsTo will only check if source points to target, not what target references.

Thrown if errors that set errno occur.

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.

//Revert to a default value upon an error:

assert("x".to!int().ifThrown(0) == 0);

//Chaining multiple calls to ifThrown to attempt multiple things in a row:

string s="true";
assert(s.to!int().
        ifThrown(cast(int)s.to!double()).
        ifThrown(cast(int)s.to!bool())
        == 1);

//Respond differently to different types of errors

assert(enforce("x".to!int() < 1).to!string()
        .ifThrown!ConvException("not a number")
        .ifThrown!Exception("number too small")
        == "not a number");

//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)));

//Use a lambda to get the thrown object.

assert("%s".format().ifThrown!Exception(e => e.classinfo.name) == "std.format.FormatException");