I went the other way round and wrote something more compile-time oriented:

usage:

match!(fun1, fun2, fun3)(someValues...); // as many values as you wish

where the funX can be template functions (or anything template-y _and_ callable), to harness the pattern matching inherent in templates, variadic templates, and so on.

For example, given:

string any(T...)(T t) { return "any: " ~ typeof(t).stringof;}

T one(T)(T t) { return t;}

T[] twoEqual(T)(T t1, T t2) { return [t1,t2];}

Tuple!(T,U) twoDiff(T,U)(T t, U u) { return tuple(t,u);}

string three(T)(T t1, T t2, T t3) { return T.stringof ~ " thrice";}

you can do:

alias match!(one, twoEqual, twoDiff, three, any) matcher;

auto m = matcher(1);     // 1
auto m = matcher(1,2); // [1,2]
auto m = matcher(1,'a'); // Tuple!(int,char)(1,'a')
auto m = matcher(1,2,3,4); // string "any: (int,int,int,int)"

You can also use standard functions, of course, and mix templates and functions.
I used this to create trees of tuples (tuples of values and tuples) and pattern-match on them. It's far from being as beautiful as Haskell code, but it's enough for my needs.

One interest compared to function overload is that you can have different return types depending on the function you give it as params.

I have another version that deconstruct the values: if you send it a struct containing two ints and one of your function has two ints as params, it will match. But it's buggy as hell and I sould have a look at it before posting it.

For match, here is the code:

template match(alias fun, Rest...) {
    auto match(M...)(M m) { // curried template...
            return Matcher!(fun, M.length, M, Rest)(m)();
    }
}

struct Matcher(alias fun, size_t n, Rest...) {
    TypeTuple!(Rest[0..n]) _m;
    this(TypeTuple!(Rest[0..n]) m) { _m = m;}
    auto opCall() {
        static if (is(typeof(fun(_m))))
            return fun(_m);
        else static if (n == 1 && is(typeof(fun(_m[0])))) // I'm not sure this is necessary
            return fun(_m[0]);
        else static if (Rest.length > n) {
            return Matcher!(Rest[n], n, Rest[0..n], Rest[n+1..$])(_m)();
        }
        else { // no match found, we are at the end of Rest
            string s;
            foreach(i, Type; TypeTuple!(Rest[0..n])) s ~= to!string(_m[i]);
            throw new NoMatchException("No match for " ~ s ~ " of type " ~ typeof(_m).stringof);
        }
    }
}

Half the complexity and ugliness comes from my wanting to have a variadic function in the end: I did_not_ want have to wrap my arguments in a tuple, as it's done for std.concurrency, IIRC.
Also, I use functions like (...) { some code } or (T...)(T t) { } to get a function that matches everything, not a (Variant v) { }
 
Philippe