在花了很多时间阅读和思考之后，我想我终于掌握了 monad 是什么、它们如何工作以及它们有什么用处。我的主要目标是弄清楚 monad 是否可以应用于我在 C# 中的日常工作。

当我开始学习 monad 时，我的印象是它们很神奇，它们以某种方式使 IO 和其他非纯函数变得纯。

我理解 monad 对于 .Net 中的 LINQ 之类的东西的重要性，并且 Maybe 对于处理不返回有效值的函数非常有用。我也很欣赏限制代码状态和​​隔离外部依赖的需要，我希望 monad 也能帮助解决这些问题。

但我最终得出结论，用于 IO 和处理状态的 monad 是 Haskell 的必需品，因为 Haskell 没有其他方法可以做到这一点(否则，你无法保证顺序，并且一些调用会被优化离开。)但对于更主流的语言，monad 不能很好地满足这些需求，因为大多数语言已经很容易处理和声明和 IO。

所以，我的问题是，可以说 IO monad 真的只在 Haskell 中有用吗？在 C# 中实现 IO monad 是否有充分的理由？

最佳答案

在工作中，我们在最重要的业务逻辑部分使用 monad 来控制 C# 代码中的 IO。两个例子是我们的财务代码和为我们的客户找到优化问题解决方案的代码。

在我们的财务代码中，我们使用 monad 来控制 IO 写入和读取数据库。它本质上由一小组操作和一个用于 monad 操作的抽象语法树组成。您可以想象它是这样的(不是实际代码):

interface IFinancialOperationVisitor<T, out R> : IMonadicActionVisitor<T, R> {
    R GetTransactions(GetTransactions op);
    R PostTransaction(PostTransaction op);
}

interface IFinancialOperation<T> {
    R Accept<R>(IFinancialOperationVisitor<T, R> visitor);
}

class GetTransactions : IFinancialOperation<IError<IEnumerable<Transaction>>> {
    Account Account {get; set;};

    public R Accept<R>(IFinancialOperationVisitor<R> visitor) {
        return visitor.Accept(this);
    }
}

class PostTransaction : IFinancialOperation<IError<Unit>> {
    Transaction Transaction {get; set;};

    public R Accept<R>(IFinancialOperationVisitor<R> visitor) {
        return visitor.Accept(this);
    }
}

本质上是 Haskell 代码

data FinancialOperation a where
     GetTransactions :: Account -> FinancialOperation (Either Error [Transaction])
     PostTransaction :: Transaction -> FinancialOperation (Either Error Unit)

连同用于在 monad 中构建操作的抽象语法树，本质上是自由 monad:

interface IMonadicActionVisitor<in T, out R> {
    R Return(T value);
    R Bind<TIn>(IMonadicAction<TIn> input, Func<TIn, IMonadicAction<T>> projection);
    R Fail(Errors errors);
}    

// Objects to remember the arguments, and pass them to the visitor, just like above

/*
Hopefully I got the variance right on everything for doing this without higher order types, 
which is how we used to do this. We now use higher order types in c#, more on that below. 
Here, to avoid a higher-order type, the AST for monadic actions is included by inheritance 
in 
*/

在真实的代码中，有更多这样的代码所以我们可以记住一些东西是由 .Select() 构建的而不是 .SelectMany()为了效率。包括中间计算在内的财务操作仍然具有类型 IFinancialOperation<T> .操作的实际执行是由解释器完成的，解释器将所有数据库操作包装在一个事务中，并处理在任何组件不成功时如何回滚该事务。我们还使用解释器对代码进行单元测试。

在我们的优化代码中，我们使用 monad 来控制 IO 以获取外部数据以进行优化。这允许我们编写不知道计算是如何组成的代码，这让我们可以在多个设置中使用完全相同的业务代码:

• 用于按需完成计算的同步 IO 和计算
• 许多并行计算的异步 IO 和计算
• 用于单元测试的模拟 IO

由于代码需要传递使用哪个monad，我们需要一个monad的显式定义。这是一个。 IEncapsulated<TClass,T>本质上意味着 TClass<T> .这让 c# 编译器可以同时跟踪 monad 类型的所有三个部分，从而克服了在处理 monad 本身时进行强制转换的需要。

public interface IEncapsulated<TClass,out T>
{
    TClass Class { get; }
}

public interface IFunctor<F> where F : IFunctor<F>
{
    // Map
    IEncapsulated<F, B> Select<A, B>(IEncapsulated<F, A> initial, Func<A, B> projection);
}

public interface IApplicativeFunctor<F> : IFunctor<F> where F : IApplicativeFunctor<F>
{
    // Return / Pure
    IEncapsulated<F, A> Return<A>(A value);
    IEncapsulated<F, B> Apply<A, B>(IEncapsulated<F, Func<A, B>> projection, IEncapsulated<F, A> initial);
}

public interface IMonad<M> : IApplicativeFunctor<M> where M : IMonad<M>
{
    // Bind
    IEncapsulated<M, B> SelectMany<A, B>(IEncapsulated<M, A> initial, Func<A, IEncapsulated<M, B>> binding);
    // Bind and project 
    IEncapsulated<M, C> SelectMany<A, B, C>(IEncapsulated<M, A> initial, Func<A, IEncapsulated<M, B>> binding, Func<A, B, C> projection);
}

public interface IMonadFail<M,TError> : IMonad<M> {
    // Fail
    IEncapsulated<M, A> Fail<A>(TError error);
}

现在我们可以想象为我们的计算需要能够看到的 IO 部分创建另一个 monad 类:

public interface IMonadGetSomething<M> : IMonadFail<Error> {
    IEncapsulated<M, Something> GetSomething();
}

然后我们可以编写不知道计算是如何组合在一起的代码

public class Computations {

    public IEncapsulated<M, IEnumerable<Something>> GetSomethings<M>(IMonadGetSomething<M> monad, int number) {
        var result = monad.Return(Enumerable.Empty<Something>());
        // Our developers might still like writing imperative code
        for (int i = 0; i < number; i++) {
            result = from existing in r1
                     from something in monad.GetSomething()
                     select r1.Concat(new []{something});
        }
        return result.Select(x => x.ToList());
    }
}

这可以在 IMonadGetSomething<> 的同步和异步实现中重用.请注意，在此代码中，GetSomething()即使在异步设置中，s 也会一个接一个地发生，直到出现错误。 (不，这不是我们在现实生活中构建列表的方式)

关于c# - IO monad 在像 C# 这样的语言中有意义吗，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21364837/