Difficulties with std.variant.Algebraic

[Meta]

I've been playing around with std.variant.Algebraic, trying to 
define a very simple option type. However, I've been running into 
quite a few problems. My implementation is as follows:

import std.conv;
import std.variant;
struct Some(T)
{
    T payload;

    alias payload this;
}

struct None
{
}

struct Option(T)
{       
    Algebraic!(Some!T, None) payload;

    alias payload this;
}

Option!int unreliable(int val)
{
    if (val == 0)
    {
        return None();
    }
    else
    {
        return Some!int(val);
    }
}


Unfortunately, I can't return values of type Some or None from 
"unreliable" and expect the compiler to know that they should 
become an Algebraic wrapped in an Option. This is annoying, but I 
can't expect magic. Maybe if I'm explicit:

Option!int unreliable(int val)
{
    if (val == 0)
    {
        //Nope
        return cast(Option!int)None();
    }
    else
    {
        //Nope
        return cast(Option!int)Some!int(val);
    }
}

Option!int unreliable(int val)
{
    if (val == 0)
    {
        //Nope
        return cast(Option!int)None();
    }
    else
    {
        //Nope
        return cast(Option!int)Some!int(val);
    }
}

Option!int unreliable(int val)
{
    if (val == 0)
    {
        //Nope
        return cast(Algebraic!(Some!int, None))None();
    }
    else
    {
        //Nope
        return cast(Algebraic!(Some!int, None))Some!int(val);
    }
}


Okay, I'll try constructing a fresh struct and returning that:

Option!int unreliable(int val)
{
    if (val == 0)
    {
        //Nope
        return Option!int(None());
    }
    else
    {
        //Nope
        return Option!int(Some!int(val));
    }
}


One final, last-ditch effort:

Option!int unreliable(int val)
{
    if (val == 0)
    {
        return Option!int(cast(Algebraic!(Some!int, None))None());
    }
    else
    {
        return Option!int(cast(Algebraic!(Some!int, 
None))Some!int(val));
    }
}


Yes! It worked. The only problem is that this is completely 
unacceptable to type. The only other solution I can think of 
would be to define constructors for Option that take a Some and a 
None. I suppose it's not *all* bad, though. I mean, it compiles...

void main()
{
    auto maybeNone = unreliable(10);
    //Error: template std.variant.visit cannot deduce template 
function from argument types !()(Option!(int))
    assert(maybeNone.visit!((Some!int s) => text("Value is ", s),
                            (None n) => "No value")
                    == 10);
}


I don't know whether to laugh or cry.