如何在D中实现Haskell*Maybe*构造？

我想实现D中Haskell的

也许

，只是为了好玩。 到目前为止，这就是我所得到的，但不是很好。有什么改进的办法吗

class Maybe(a = int){ }  //problem 1: works only with ints

class Just(alias a) : Maybe!(typeof(a)){ }

class Nothing : Maybe!(){ }


Maybe!int doSomething(in int k){

  if(k < 10)
    return new Just!3;  //problem 2: can't say 'Just!k'
  else
    return new Nothing;
}

如果你用这个怎么办

class Maybe(T){ }  

class Just(T) : Maybe!(T){ 
T t;
this(T t){
this.t = t;
}
}
class Nothing : Maybe!(){ }


Maybe!int doSomething(in int k){

  if(k < 10)
    return new Just!int(3); 
  else
    return new Nothing;
}

类可能（T）{
全班同学（T）：也许吧！（T） {
T；
这个（T）{
t=t；
}
}
全班同学：也许吧！(){ }
大概整数剂量测量法（整数k）{
if（k<10）
返回新的Just！int（3）；
其他的
不归还新的东西；
}

---

就我个人而言，我会使用带标记的联合和结构（并且

强制执行
这是一个获取值的正确方法）
我没有使用Maybe库，但类似的东西似乎符合要求：

import std.stdio;

struct Maybe(T)
{
    private {
        bool isNothing = true;
        T value;
    }

    void opAssign(T val)
    {
        isNothing = false;
        value = val;
    }

    void opAssign(Maybe!T val)
    {
        isNothing = val.isNothing;
        value = val.value;
    }

    T get() @property
    {
        if (!isNothing)
            return value;
        else
            throw new Exception("This is nothing!");
    }

    bool hasValue() @property
    {
        return !isNothing;
    }
}

Maybe!int doSomething(in int k)
{
    Maybe!int ret;

    if (k < 10)
        ret = 3;
    return ret;     
}

void main()
{
    auto retVal = doSomething(5);
    assert(retVal.hasValue);
    writeln(retVal.get);

    retVal = doSomething(15);
    assert(!retVal.hasValue);
    writeln(retVal.hasValue);
}

导入标准stdio；
结构（T）
{
私人的{
bool is nothing=true；
T值；
}
无效opAssign（T val）
{
isNothing=假；
值=val；
}
无效opAssign（可能！T val）
{
isNothing=val.isNothing；
value=val.value；
}
无法获取（）属性
{
如果（！isNothing）
返回值；
其他的
抛出新异常（“这没什么！”；
}
bool hasValue（）@属性
{
返回！什么都不是；
}
}
大概整数剂量测量法（整数k）
{
也许吧！内网；
if（k<10）
ret=3；
返回ret；
}
void main（）
{
自动回收=剂量测定（5）；
断言（retVal.hasValue）；
writeln（retVal.get）；
retVal=剂量测定法（15）；
断言（！retVal.hasValue）；
writeln（retVal.hasValue）；
}

通过一些创造性的操作符重载，Maybe结构可以表现得非常自然。此外，我还对Maybe结构进行了模板化，因此它可以用于任何类型。
请看。它与Haskell中的
可能
不完全相同，但它是一种可选的类型，可以保存实例化时使用的任何类型的值。所以，实际上，它就像哈斯克尔的
也许
，虽然在语法上，它有点不同。如果你想看的话，源代码就是。
我看了一下源代码，它看起来与Justin发布的类似。如果是在火卫一，为什么还要费心重新发明轮子呢？我将使用Nullable，：）是的，与Haskell
可能不完全一样，但足够接近。它是否适合你的行为取决于你正在尝试做什么。一般来说，我鼓励您使用
Nullable
，因为它在标准库中，但是如果您的主要目的只是学习（正如您的问题所暗示的那样），那就不同了。
import std.stdio;

struct Maybe(T)
{
    private {
        bool isNothing = true;
        T value;
    }

    void opAssign(T val)
    {
        isNothing = false;
        value = val;
    }

    void opAssign(Maybe!T val)
    {
        isNothing = val.isNothing;
        value = val.value;
    }

    T get() @property
    {
        if (!isNothing)
            return value;
        else
            throw new Exception("This is nothing!");
    }

    bool hasValue() @property
    {
        return !isNothing;
    }
}

Maybe!int doSomething(in int k)
{
    Maybe!int ret;

    if (k < 10)
        ret = 3;
    return ret;     
}

void main()
{
    auto retVal = doSomething(5);
    assert(retVal.hasValue);
    writeln(retVal.get);

    retVal = doSomething(15);
    assert(!retVal.hasValue);
    writeln(retVal.hasValue);
}