Change Log: 2.064

module libweb.client;

void runClient() { }

module libweb.server;

void runServer() { }

module libweb;

public import libweb.client;
public import libweb.server;

module test;

import libweb;

void main()
{
    startServer();
    startClient();
}

module libweb.utils;  // fully qualified name of the package, not just "utils"!

// publicly import modules from within the 'libweb.utils' package.
public import libweb.utils.conv;
public import libweb.utils.text;

module test;

import libweb.utils;

void main()
{
}

template Tuple(T...) { alias Tuple = T; }

template isIntOrFloat(T)
{
    static if (is(T == int) || is(T == float))
        enum isIntOrFloat = true;
    else
        enum isIntOrFloat = false;
}

void main()
{
    alias Tup = Tuple!(int, float, string);
    static assert(isIntOrFloat!(Tup[0]));  // int is an int or a float
    static assert(isIntOrFloat!(Tup[1]));  // float is an int or a float
    static assert(!isIntOrFloat!(Tup[2])); // string is neither an int nor a float
}

alias Tuple(T...) = T;

enum isIntOrFloat(T) = is(T == int) || is(T == float);

void main()
{
    alias Tup = Tuple!(int, float, string);
    static assert(isIntOrFloat!(Tup[0]));  // int is an int or a float
    static assert(isIntOrFloat!(Tup[1]));  // float is an int or a float
    static assert(!isIntOrFloat!(Tup[2])); // string is neither an int nor a float
}

class Server
{
    this(string[] args) { }
    void run() { }
}

void main(string[] args)
{
    (new Server(args)).run();
}

class Server
{
    this(string[] args) { }
    void run() { }
}

void main(string[] args)
{
    new Server(args).run();
}

class Server
{
    this() { }
    void run() { }
}

void main()
{
    new Server.run();    // error
    new Server().run();  // ok
}

IFTI has been improved, allowing you to write code such as the following:

struct A
{
    struct Foo { }
}

struct B
{
    struct Foo { }
}

/**
Templated function which expects the second argument to be of type 'Foo,
which is a nested in the type 'T'.
*/
void call(T)(T t, T.Foo foo) { }

void main()
{
    auto a = A();
    auto a_f = A.Foo();
    call(a, a_f);  // ok

    auto b = B();
    auto b_f = B.Foo();
    call(b, b_f);  // ok

    call(a, b_f);  // fails: b_f is typed as B.Foo, not A.Foo
}

This IFTI feature also allows you to retrieve the module of a symbol, by using an alias template parameter, rather than a type one:

module my_module;

struct A
{
    struct B { }
}

void foo(alias Mod)(Mod.A, Mod.A.B)
{
    // 'Mod' is deduced to be the module 'my_module' which encloses the struct 'A'
    static assert(__traits(isSame, Mod, my_module));
}

void main()
{
    A a;
    A.B b;
    foo(a, b);  // ok
}

Here is an example documented function, where the parameter names are wrongly documented:

/**
    This is the sum function.

    params:
        x = The first parameter
        y = The second parameter
*/
int sum(int a, int b)
{
    return a + b;
}

Generating the documentation with warnings enabled will emit the following:

dmd -D -c -w test.d

test.d(8): Warning: Ddoc: function declaration has no parameter 'x'
test.d(8): Warning: Ddoc: function declaration has no parameter 'y'

This feature can help ensure that the documentation for library code is always kept up-to-date.

Note: Remember to use the -w switch when building the documentation with the -D switch in order to enable these warnings.

To help ease interacting with C libraries which expect strings as null-terminated pointers, slicing string literals (not variables!) will now allow the implicit conversion to such a pointer:

extern(C) void call(const(char)* str) { }

void main()
{
    const(char)* abc = "abc";
    call(abc);  // already previously allowed

    const(char)* ab = "abc"[0 .. 2];
    call(ab);   // allowed in 2.064
}

auto foo(int n) { return 1; }
auto foo(T)(T t) { return 2; }

void main()
{
    assert(foo(100) == 1);
    assert(foo("a") == 2);

    // Integer literal 10L can be converted to int without loss of precisions.
    // Then the call matches to foo(int n).
    assert(foo(10L) == 1);

    // A runtime variable 'num' typed long is not implicitly convertible to int.
    // Then the call matches to foo(T)(T t).
    long num = 10L;
    assert(foo(num) == 2);
}

Template declarations are now overloadable just like regular function declarations. Templates with matching names from multiple modules will introduce an overload set:

module a;

template Traits(T) if (is(T == double))
{
    enum Traits = "abc";
}

auto func(T, A...)(A args) if (is(T == double))
{
    return 1;
}

module b;

template Traits(T) if (is(T == string))
{
    enum Traits = "def";
}

auto func(T, A...)(A args) if (is(T == string))
{
    return 2;
}

module c;
import a, b;
static assert(Traits!double == "abc");  // matches to a.Traits
static assert(Traits!string == "def");  // matches to b.Traits
void main()
{
    assert(func!double(1, "msg") == 1);  // matches to a.func(T, A...)
    assert(func!string(1, "msg") == 2);  // matches to b.func(T, A...)
}

Limitations:

Merging template overload sets by using an alias declaration is currently not supported. The limitation will be lifted in a future release.

You can now use the -deps switch without having to specify a filename. The dependencies will then be printed to standard output, allowing both users and tools to introspect the dependencies in the output.

The types of dependencies which are printed out are as follows:

depsImport: Module imports found (same as -deps=file output, except prefixed with depsImport)

depsVersion: Versions (except standard ones and ones set in the module itself)

depsFile: String imports found, e.g. string x = import("foo.txt");

depsLib: Libraries specified with a pragma(lib) statement

depsDebug: Any debug() statements found (except the ones set in the module itself)

With the new getUnitTests trait you can retrieve all unittest in a module or an aggregate, and then run the tests manually. Here's an example of implementing a custom unittest running routine which prints out some additional statistics:

import core.runtime;
import core.exception;
import std.stdio;

shared static this()
{
    // this overrides the default D runtime unittest runner function,
    // since we're providing a __traits-based one in our main function.
    Runtime.moduleUnitTester = { return true; };
}

unittest
{
    assert(1);  // passes.
}

unittest
{
    assert(0);  // fails.
}

unittest
{
    assert(1);  // passes.
}

void main()
{
    Throwable[] errors;  // collect all thrown exceptions.
    size_t passCount;    // count the number of unittests which pass.

    // iterate over each unittest (this is a tuple).
    foreach (test; __traits(getUnitTests, my_module))
    {
        try
        {
            test();
            passCount++;
        }
        catch (Throwable error)
        {
            errors ~= error;
        }
    }

    // print out the errors or the statistics.
    if (errors.length)
    {
        writeln("Some unittests failed:\n");
        foreach (error; errors)
            writeln(error);
    }
    else
    {
        writefln("All unittests passed. Passed unittest count: %s", passCount);
    }
}

Note: You must compile with the -unittest flag to be able to retrieve the unittests.

Note: By default the D runtime provides its own unittest execution function. If you want to avoid it from being invoked at runtime (before the main function is called) you need to set a custom one by assigning to Runtime.moduleUnitTester in the module constructor. The one used in the above test-case simply returns true, which allows the main function to be called.

Note: The getUnitTests trait is not recursive. This means that calling it on a module will not retrieve unittests which are nested in aggregates in that module.

You can use this trait to get the index of a virtual method in the virtual method table:

class C
{
    void foo() { }
    void bar() { }
}

class D : C
{
    void doo() { }
    void doo(int) { }
    void doo(double) { }
}

void main()
{
    /**
        Note that each class implicitly inherits from the Object class,
        so the following will most likely not begin with index 0.
    */
    pragma(msg, __traits(getVirtualIndex, D.foo));
    pragma(msg, __traits(getVirtualIndex, D.bar));

    /**
        When dealing with overloads you can use the getOverloads trait to index
        into a specific method
    */
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[0]));
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[1]));
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[2]));
}

class Base
{
    void foo() { }
}

class Foo : Base
{
    override void foo() { }
    void bar() { }
}

static assert (__traits(isOverrideFunction, Base.foo) == false);
static assert (__traits(isOverrideFunction, Foo.foo)  == true);
static assert (__traits(isOverrideFunction, Foo.bar)  == false);

Sometimes you may want your class to be usable with a function which expects a specific interface argument type, but you do not necessarily want to edit the class to inherit that interface. The class could also be implemented in another library for which you do not have the source code, which means you wouldn't be able to edit the inheritance list of that class.

The new wrap function allows you to perform a structural cast, allowing a class object to act as if it were an object of another type. For example (note: for now please pass the -allinst flag to dmd when compiling):

import std.typecons;

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
}

class ImageDraw  // note: it does not inherit IDrawable.
{
    void drawLine(int x1, int y1, int x2, int y2) { }
}

/** Draw a rectangle outline. */
void drawRect(IDrawable draw)
{
    draw.drawLine(  0,   0, 100,   0);
    draw.drawLine(100,   0, 100, 100);
    draw.drawLine(  0, 100, 100, 100);
    draw.drawLine(  0,   0,   0, 100);
}

void main()
{
    auto imageDraw = new ImageDraw();
    drawRect(imageDraw);  // error: can't call this, ImageDraw is not an IDrawable.

    // perform a structural cast.
    IDrawable i = wrap!IDrawable(imageDraw);
    drawRect(i);  // and now imageDraw can act as an IDrawable.
}

The wrap function can also be used with classes which define an opDispatch function, for example:

import std.typecons;

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
    void drawRect(int x, int y, int width, int height);
}

class ImageDraw
{
    void opDispatch(string name, Args...)(Args args)
        if (name == "drawLine")
    {
        // ...
    }

    void opDispatch(string name, Args...)(Args args)
        if (name == "drawRect")
    {
        // ...
    }
}

/** Draw some shapes. */
void drawShapes(IDrawable draw)
{
    draw.drawLine(0, 100, 100, 0);
    draw.drawRect(0, 0, 100, 100);
}

void main()
{
    auto imageDraw = new ImageDraw();
    IDrawable i = wrap!IDrawable(imageDraw);
    drawShapes(i);
}

You can unwrap a structurally cast object back to its original type:

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
}

class ImageDraw
{
    void drawLine(int x1, int y1, int x2, int y2) { }
}

void main()
{
    auto imageDraw = new ImageDraw();

    // perform a structural cast (note the simple UFCS syntax).
    IDrawable i = imageDraw.wrap!IDrawable;

    // get back the original type (ditto, using UFCS syntax).
    ImageDraw draw = i.unwrap!ImageDraw;
}

And you can structurally cast to multiple interface types:

import std.typecons;

unittest
{
    interface IStoppable { void stop(); }
    interface IRunnable { void run(); }

    class Timer
    {
        void run() { }
        void stop() { }
    }

    auto timer = new Timer();
    auto obj = timer.wrap!(IStoppable, IRunnable);

    // extract the individual structurally casted types
    // from the wrapped type
    IStoppable iStop = obj;
    IRunnable  iRun  = obj;

    iRun.run();
    iStop.stop();
}

Since 2.064, pure functions can take advantage of to and format. For example:

import std.conv;
import std.string;

void main() pure  // this main is a pure function.
{
    string date = format("%s.%s.%s", 2013, 12, 10);
    int one = to!int(1.0);
}

The new generic strip functions allow you to not only strip strings but also any other Input range (stripLeft) or Bidirectional range (strip/stripRight), for example:

import std.algorithm;

void main()
{
    // strip whitespace.
    assert("  foobar  ".strip!(a => a == ' ')() == "foobar");

    // an audio waveform.
    float[] data = [0.0, 0.0, 0.1, 0.5, 0.2];

    // strip leading silence in the waveform.
    assert(data.strip!(a => a < 0.1)().length == 3);
}

To avoid implicit memory allocations translate now features overloads which can take an output range to write the contents to. For example:

import std.array;
import std.string;

void main()
{
    dchar[dchar] transTable = ['a' : '1', 'b' : '2', 'c': '3'];

    // create our output range by using the Phobos Appender.
    auto buffer = appender!(dchar[])();

    auto toRemove = null;  // don't remove any characters.

    translate("abcdef", transTable, toRemove, buffer);
    assert(buffer.data == "123def");

    // or use a static array to avoid heap allocations.
    // note: if the buffer is too small an exception will be thrown.
    dchar[6] dbuffer;
    translate("abcdef", transTable, toRemove, dbuffer[]);
    assert(dbuffer == "123def");
}

With the thisExePath function you can retrieve the current executable path:

import std.file;
import std.stdio;

void main(string[] args)
{
    // Prints the full path of the current running executable.
    // Note: this may, or may not be the same as args[0]. The content
    // of args[0] is dependent of how the application was invoked, thisExePath()
    // is not. It's also possible to access thisExePath() from other parts of the
    // code than main.
    writeln(thisExePath());
}

The old API based around "g"(=global) flag was confusing and error prone. Moreover in some cases it was already being overriden by a function as is the case with std.regex.splitter.

New version ties the operation to the function in question, thus being simpler to understand without extra context. For the moment the "g" flag is kept working as is but the new API always overrides it where applicable. Another addition in the new API is an overload for the replace family of functions to work directly with output ranges.

To understand the difference in the API compare 2 samples below.

Before 2.064:

void main()
{
    import std.regex, std.algorithm, std.range, std.stdio, std.string;
    auto m = "3.141592".match(`(\d+)\.(\d+)`);
    // m is a range of ranges
    assert(m.front.equal(["3.141592", "3", "141592"]));

    // global vs non-global
    auto word = regex(`(\w)\w*`);
    auto gword = regex(`(\w)\w*`, "g");
    auto list = "tomatoes, potatoes, pineapple";
    // this will print only 'tomatoes', which raised many questions
    foreach(item; list.match(word))
        writeln(item.hit);

    // while this will print each of them
    foreach(item; list.match(gword))
        writeln(item.hit);

    auto justFirst = replace!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(justFirst == "Tomatoes, potatoes, pineapple");
    auto allOfThem = replace!(m => toUpper(m[1]) ~ m[0].drop(1))(list, gword);
    assert(allOfThem == "Tomatoes, Potatoes, Pineapple");
}

After 2.064:

void main()
{
    import std.regex, std.algorithm, std.range, std.stdio, std.string;
    auto m = "3.141592".matchFirst(`(\d+)\.(\d+)`);
    // m is simply a range of submatches
    assert(m.equal(["3.141592", "3", "141592"]));

    auto word = regex(`(\w)\w*`);
    auto list = "tomatoes, potatoes, pineapple";
    // iterates over submatches so it will print 2 lines:
    // tomatoes
    // t
    foreach(item; list.matchFirst(word))
        writeln(item);
    // so just to get the whole match:
    assert(list.matchFirst(word).hit == "tomatoes");

    // now there is no need to check if it has "g" option
    // it's crystal clear in the function name
    foreach(item; list.matchAll(word))
        writeln(item.hit);

    auto justFirst = replaceFirst!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(justFirst == "Tomatoes, potatoes, pineapple");
    auto allOfThem = replaceAll!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(allOfThem == "Tomatoes, Potatoes, Pineapple");

    // NEW feature - if there is no need to allocate, the resulting string
    // replacement may be just sent directly to the wire (an OutputRange)
    auto sink = stdout.lockingTextWriter();
    replaceAllInto!(m => toUpper(m[1]) ~ m[0].drop(1))(sink, list, word);
}

The old API still works, even though eventual deprecation is planned. Also note the new functionality in form of *Into functions that forward the replacement directly to an output range avoiding extra pressure on the heap.

Now ctRegex supports full syntax spectrum of run-time one except for set algebra inside of a character class. For instance, the following now compiles and passes:

void main()
{
    import std.regex;
    // a word, but not a title-cased ASCII
    // ?<! inside of () means "negative lookbehind"
    auto pat = ctRegex!`\w+(?<![A-Z][a-z]*)`;
    assert(!"Hello".match(pat));
    assert("good_bay".match(pat));
}