8

我正在尝试更深入地了解 Monads。因此，我开始深入研究 Maybe Monad。

有一件事我似乎没有做对。读这个：

“因此，Maybe Bind 起到了短路的作用。在任何一个操作链中，如果其中任何一个返回 Nothing，则评估将停止，整个链将返回 Nothing。”

来自： http: //mikehadlow.blogspot.com/2011/01/monads-in-c-5-maybe.html

还有这个：

“对于Maybe<T>类型，绑定是根据简单的规则实现的：如果链在某个点返回一个空值，则链中的进一步步骤将被忽略，而是返回一个空值”

来自：“C# 中的函数式编程” http://www.amazon.com/Functional-Programming-Techniques-Projects-Programmer/dp/0470744588/

好的，让我们看一下代码。这是我的Maybe Monad：

public class Maybe<T>
{
    public static readonly Maybe<T> Empty = new Maybe<T>(); 

    public Maybe(T value)
    {
        Value = value;
    }

    private Maybe()
    {
    }

    public bool HasValue()
    {
        return !EqualityComparer<T>.Default.Equals(Value, default(T));
    }

    public T Value { get; private set; }

    public Maybe<R> Bind<R>(Func<T, Maybe<R>> apply)
    {
        return HasValue() ? apply(Value) : Maybe<R>.Empty;
    }
}

public static class MaybeExtensions
{
    public static Maybe<T> ToMaybe<T>(this T value)
    {
        return new Maybe<T>(value);
    }
}

这是我使用 monad 的示例代码：

class Program
{
    static void Main(string[] args)
    {
        var node = new Node("1", new Node("2", new Node("3", new Node("4", null))));

        var childNode = node.ChildNode
            .ToMaybe()
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x => x.ChildNode.ToMaybe());

        Console.WriteLine(childNode.HasValue() ? childNode.Value.Value : "");

        Console.ReadLine();
    }
}

public class Node
{
    public Node(string value, Node childNode)
    {
        Value = value;
        ChildNode = childNode;
    }

    public string Value { get; set; }
    public Node ChildNode { get; private set; }
}

很明显，我们正在尝试比可能更深入地挖掘节点树。但是，根据我提到的报价，我看不到它是如何运作的。我的意思是，我当然已经排除了空检查并且示例有效。然而，它并没有提前打破这个链条。如果设置断点，您将看到每个Bind()操作都将被使用，因此没有最后一个操作的值。但这意味着，如果我深挖 20 层而实际上只下降了 3 层，我仍然会检查 20 层还是我错了？

将此与非单子方法进行比较：

        if (node.ChildNode != null
            && node.ChildNode.ChildNode != null
            && node.ChildNode.ChildNode.ChildNode != null)
        {
            Console.WriteLine(node.ChildNode.ChildNode.ChildNode.Value);
        }

这难道不应该叫短路吗？因为在这种情况下 if 真的在第一个值为 null 的级别中断。

有人可以帮我弄清楚吗？

更新

正如 Patrik 指出的那样，是的，即使我们只有 3 个级别并尝试深入 20 个级别，每个绑定都会被调用。但是，不会计算提供给 Bind() 调用的实际表达式。我们可以编辑示例以使效果更清晰：

        var childNode = node.ChildNode
            .ToMaybe()
            .Bind(x =>
                      {
                          Console.WriteLine("We will see this");
                          return x.ChildNode.ToMaybe();
                      })
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x => x.ChildNode.ToMaybe())
            .Bind(x =>
                      {
                          Console.WriteLine("We won't see this");
                          return x.ChildNode.ToMaybe();
                      });
4

3 回答 3

12

我在 c# 中有一个可能的 monad 的实现，它与你的略有不同，首先它不依赖于空检查，我相信我的实现更接近于标准可能实现中发生的事情，例如 Haskel。

我的实现：

public abstract class Maybe<T>
{
    public static readonly Maybe<T> Nothing = new NothingMaybe();

    public static Maybe<T> Just(T value)
    {
        return new JustMaybe(value);
    }

    public abstract Maybe<T2> Bind<T2>(Func<T, Maybe<T2>> binder);

    private class JustMaybe
        : Maybe<T>
    {
        readonly T value;

        public JustMaybe(T value)
        {
            this.value = value;
        }

        public override Maybe<T2> Bind<T2>(Func<T, Maybe<T2>> binder)
        {
            return binder(this.value);
        }
    }

    private class NothingMaybe
        : Maybe<T>
    {
        public override Maybe<T2> Bind<T2>(Func<T, Maybe<T2>> binder)
        {
            return Maybe<T2>.Nothing;
        }
    }
}

正如您在此处看到的，NothingMaybe 的绑定函数只返回一个新的无，因此永远不会评估传入的绑定表达式。从某种意义上说，这是一种短路，一旦您进入“无状态”，将不再评估绑定器表达式，但是将为链中的每个 monad 调用绑定函数本身。

这种可能的实现可以用于任何类型的“不确定操作”，例如空检查或空字符串检查，这样所有这些不同类型的操作都可以链接在一起：

public static class Maybe
{
    public static Maybe<T> NotNull<T>(T value) where T : class
    {
        return value != null ? Maybe<T>.Just(value) : Maybe<T>.Nothing;
    }

    public static Maybe<string> NotEmpty(string value)
    {
        return value.Length != 0 ? Maybe<string>.Just(value) : Maybe<string>.Nothing;
    }


}

string foo = "whatever";
Maybe.NotNull(foo).Bind(x => Maybe.NotEmpty(x)).Bind(x => { Console.WriteLine(x); return Maybe<string>.Just(x); });

这会将“whatever”打印到控制台，但是如果值为 null 或为空，它将什么也不做。

于 2011-11-26T11:20:55.347 回答
5

据我了解，Bind将调用所有方法，但仅当前一个返回值时才会评估提供的表达式。这意味着在返回（或更准确地说Bind：）之后调用的方法将非常便宜。nulldefault(T)

于 2011-11-26T11:13:53.930 回答
0

我们可以更巧妙地做到这一点。

从 IEnumerable 派生的写接口

public interface IOptional<T>: IEnumerable<T> {}

这将节省与 LINQ 方法的兼容性

public class Maybe<T>: IOptional<T>
{
    private readonly IEnumerable<T> _element;
    public Maybe(T element)
        : this(new T[1] { element })
    {}
    public Maybe()
        : this(new T[0])
    {}
    private Maybe(T[] element)
    {
        _element = element;
    }
    public IEnumerator<T> GetEnumerator()
    {
        return _element.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

在此之后，我们可以使用 LINQ 的全部功能并这样做

var node = new Node("1", new Node("2", new Node("3", new Node("4", null))));

var childNode =
    new Some<Node>(node.ChildNode)
        .SelectMany(n => new Maybe<Node>(n.ChildNode))
        .SelectMany(n => new Maybe<Node>(n.ChildNode))
        .SelectMany(n => new Maybe<Node>(n.ChildNode))
        .SelectMany(n => new Maybe<Node>(n.ChildNode))
        .SelectMany(n => new Maybe<Node>(n.ChildNode));

Console.WriteLine(childNode.Any() ? childNode.First().Value : "");
于 2017-06-28T14:22:12.893 回答