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

Question

我想在 D 中实现来自 Haskell 的 Maybe，只是为了它的地狱。 这是我到目前为止所得到的，但还不是很好。有什么想法如何改进吗？

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;
}

Haskell Maybe 定义：

data  Maybe a = Nothing | Just a

Answer 1

如果你个人使用这个，

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;
}

我会使用标记的联合和结构（并且 enforce 这是在获取值时的情况）

Answer 2

查看 std.typecons.Nullable。它与 Haskell 中的Maybe并不完全相同，但它是一种可以选择保存其实例化类型的值的类型。因此，实际上，它就像 Haskell 的 Maybe，尽管在​​语法上有点不同。如果您想查看源代码，请点击此处。

Answer 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);
}

通过一些创造性的运算符重载，Maybe 结构可以表现得非常自然。此外，我已经模板化了 Maybe 结构，因此它可以与任何类型一起使用。