Optional and NotNull version 0.5.0 - swift optional like and scala option like

[aliak]

Hi

See: https://optional.dub.pm

I've totally revamped the Optional type and am now quite happy 
with. It has a range interface and safe dispatching and can be 
used to 1) avoid null dereferencing, 2) have non-null guarantees, 
and 3) show clear intent where there may or may not be a value. 
It's also @nogc and @safe and mutation of the original object 
during safe dispatching works as well.

Some code examples:

===
import optional;
import std.stdio: writeln;

class Residence {
     auto numberOfRooms = 4;
}
class Person {
     Optional!Residence residence;
}

auto john = some(new Person());

john.dispatch.residence.dispatch.numberOfRooms.writeln; // safe, 
prints "[]"
john.dispatch.residence = new Residence();
john.dispatch.residence.dispatch.numberOfRooms.writeln; // prints 
"[4]"

if (auto res = john.dispatch.residence.unwrap) {
     writeln(res.numberOfRooms); // safe, prints "4"
}
===

And since it's a range type as well, you can use it with phobos 
algos (and it provides some primitives found in e.g. scala)

===
import std.algorithm: each;

// Make a function that may or may not parse a string to an int
Optional!int toInt(string str) {
     import std.conv: to;
     scope(failure) return no!int;
     return some(str.to!int);
}

auto x = toInt("1").orElse(0);

toInt("1").each!writeln;

toInt("1").match!(
     (i) => writeln(i),
     () => writeln("nothing there"),
);
===

The readme contains a lot more details.

Some things that are on me list that I need to think about
- Consider a short form for "dispatch". Purely for convenience:
    e.g.: john.d.residence.d.numberOfRooms;
- Consider an auto dispatch (".autoDispatch"?), so that once you 
start a chain you don't need to write "dispatch again:
    e.g.: john.autoDispatch.residence.numberOfRooms;


Some reasonings for design:
- The dispatcher is a completely separate type because Optional 
is a range type and has it's own functions that would be 
impossible to call on a type T without unwrapping first.
- The "safe dispatcher" proxy contains NO functions so that it 
will never trample over a type T.


Cheers,
- Ali