Is there anything other than nullable to work with optional types?

[aliak via Digitalmars-d-learn]

Hey,

So, been using the programming language swift for a while now, 
the optional types[1] they support makes working with maybe-type 
(ala haskell) values extremely pleasant.

Does D have anything other than the Nullable template that can be 
used to work with optionals, or is there a way for it to not be 
so cumbersome to work with?

Eg: Currently I have a function like this:

struct MarkerData {
    long start;
    long end;
    long length;
    long times;
}

Nullable!MarkerData pluckMarker(string str) {
    auto start = str.indexOf("(");
    if (start == -1) {
        return typeof(return).init;
    }
    auto end = str.indexOf(")", start);
    if (end == -1) {
        return typeof(return).init;
    }
    auto parts = str[start+1..end].split("x");
    auto length = to!long(parts[0]);
    auto times = to!long(parts[1]);
    return Nullable!MarkerData(MarkerData(start, end, length, 
times));
}

Everywhere I have to return the Nullable! type, I have to either 
use that typeof(return).init to make it a null value, or a quite 
verbose constructor call to return a concrete type.

Can it be made simpler to use without me having to alias 
Nullable!MarkerData (which still wouldn't help with just 
returning null).

[1] will try a super quick explanation of optional types. You 
basically add a '?' to any type declaration and then it's 
nullable. And you can implicitly assign nil and also the concrete 
type.