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也许定义：

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

我没有使用过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结构，所以它可以用于任何类型。

Answer 3

看看std.typecons.Nullable。它与Haskell中的Maybe不完全相同，但它是一种类型，它可以选择保存实例化的任何类型的值。所以，实际上，它就像Haskell的Maybe，虽然从语法上讲，它有点不同。如果您想查看它，则来源为here。

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

3 个答案: