我在 C# 中看到的大多数 monad 示例都是这样写的:

public static Identity<B> Bind<A, B>(this Identity<A> a, Func<A, Identity<B>> func) {
    return func(a.Value);
}

例如，参见 http://mikehadlow.blogspot.com/2011/01/monads-in-c-3-creating-our-first-monad.html .

问题是，要求 func 有什么意义？返回 Identity<B> ？如果我使用以下定义:

public interface IValue<A> {
    public IValue<B> Bind<B>(Func<A, B> func)
}

然后我实际上可以使用相同的 func对于 Lazy<T> , Task<T> , Maybe<T>等实际上不依赖于实际类型实现 IValue .

我在这里遗漏了什么重要的东西吗？

最佳答案

首先，考虑组合 的概念。我们可以轻松地将组合表达为对委托(delegate)的操作:

public static Func<T, V> Compose<T, U, V>(this Func<U, V> f, Func<T, U> g)
{
    return x => f(g(x));
}

所以如果我有一个函数 g 是 (int x) => x.ToString()和一个函数 f 是 (string s) => s.Length然后我可以创建一个组合函数 h，它是 (int x) => x.ToString().Length调用f.Compose(g) .

这应该很清楚了。

现在假设我有一个来自 T 的函数 g至 Monad<U>和来自 U 的函数 f至 Monad<V> .我希望编写一个方法，将这两个返回 monad 的函数组合成一个接受 T 的函数。并返回 Monad<V> .所以我试着这样写:

public static Func<T, Monad<V>> Compose<T, U, V>(this Func<U, Monad<V>> f, Func<T, Monad<U>> g)
{
    return x => f(g(x));
}

不起作用。 g返回 Monad<U>但是f需要 U .我有办法“包装”一个 U进入Monad<U>但我没有办法“打开”一个。

但是，如果我有一个方法

public static Monad<V> Bind<U, V>(this Monad<U> m, Func<U, Monad<V>> k)
{ whatever }

然后我可以编写一个方法，该方法由两个都返回 monad 的方法组成:

public static Func<T, Monad<V>> Compose<T, U, V>(this Func<U, Monad<V>> f, Func<T, Monad<U>> g)
{
    return x => Bind(g(x), f);
}

这就是为什么 Bind 从 T 获取函数的原因至 Monad<U> -- 因为事情的重点是能够从 T 中获取函数 g至 Monad<U>和来自 U 的函数 f至 Monad<V>并将它们组合成来自 T 的函数 h至 Monad<V> .

如果你想从T中获取函数g至 U和来自 U 的函数 f至 Monad<V>那么您一开始就不需要 Bind。只需正常编写函数 即可从T 获取方法。至 Monad<V> ! Bind 的全部目的就是解决这个问题；如果您解决了这个问题，那么您一开始就不需要 Bind。

更新:

In most cases I want to compose function g from T to Monad<U> and function f from U to V.

然后我假设您希望将其组合成来自 T 的函数至 V .但是你不能保证定义了这样的操作!例如，以“Maybe monad”作为monad，在C#中表示为T? .假设你有 g 作为 (int x)=>(double?)null你有一个函数 f 是 (double y)=>(decimal)y .您应该如何将 f 和 g 组合成一个方法，该方法接受一个 int 并返回不可为 null 的 decimal类型？没有将可为 null 的 double 解包为 f 可以采用的 double 值的“解包”!

您可以使用 Bind 将 f 和 g 组合成一个接受 int 并返回可为 null 的小数的方法:

public static Func<T, Monad<V>> Compose<T, U, V>(this Func<U, V> f, Func<T, Monad<U>> g)
{
    return x => Bind(g(x), x=>Unit(f(x)));
}

其中 Unit 是一个接受 V 的函数并返回 Monad<V> .

但是如果 g 返回一个 monad 而 f 不返回 monad，那么 f 和 g 根本就没有组合——不能保证有一种方法可以从 monad 的实例返回到一个“未包装的” “类型。也许在一些单子(monad)的情况下总是有——比如 Lazy<T> .或者有时可能会有，就像“可能”monad 一样。通常有办法做到这一点，但没有要求您可以这样做。

顺便说一下，请注意我们是如何将“Bind”用作瑞士军刀来制作一种新型组合的。绑定(bind)可以进行任何操作!例如，假设我们在序列 monad 上有 Bind 操作，我们在 IEnumerable<T> 上称之为“SelectMany”在 C# 中输入:

static IEnumerable<V> SelectMany<U, V>(this IEnumerable<U> sequence, Func<U, IEnumerable<V>> f)
{
    foreach(U u in sequence)
        foreach(V v in f(u))
            yield return v;
}

你可能还有一个序列操作符:

static IEnumerable<A> Where<A>(this IEnumerable<A> sequence, Func<A, bool> predicate)
{
    foreach(A item in sequence)
        if (predicate(item)) 
            yield return item;
}

您真的需要在 Where 中编写该代码吗？ ？不!您可以完全使用“Bind/SelectMany”构建它:

static IEnumerable<A> Where<A>(this IEnumerable<A> sequence, Func<A, bool> predicate)
{
    return sequence.SelectMany((A a)=>predicate(a) ? new A[] { a } : new A[] { } );  
}

高效？不，但是没有什么是 Bind/SelectMany 做不到的。如果你真的想要，你可以只用 SelectMany 构建所有的 LINQ 序列运算符。

关于c# - C# 中的 Monads——为什么 Bind 实现需要传递的函数来返回 monad？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7828528/