c# - C#中的Monad变形金刚

我正在研究如何在C_中使用单子变形金刚。
我想知道下面的代码是否表明我已经理解了这一点。
我对此还不太熟悉，所以任何反馈/评论都是非常受欢迎的。
这个例子只是为了将maybe monad包装到验证monad中。

using System;
using NUnit.Framework;

namespace Monads
{
    public static class MaybeExtensions
    {
        public static IMaybe<T> ToMaybe<T>(this T value)
        {
            if (value == null)
                return new None<T>();

            return new Just<T>(value);
        }
    }

    public interface IMaybe<T>
    {
        IMaybe<U> Select<U>(Func<T, U> f);

        IMaybe<U> SelectMany<U>(Func<T, IMaybe<U>> f);

        U Fold<U>(Func<U> error, Func<T, U> success);
    }

    public class Just<T> : IMaybe<T>
    {
        public Just(T value)
        {
            this.value = value;

        }

        public IMaybe<U> Select<U>(Func<T, U> f)
        {
            return f(value).ToMaybe();
        }

        public IMaybe<U> SelectMany<U>(Func<T, IMaybe<U>> f)
        {
            return f(value);
        }

        public U Fold<U>(Func<U> error, Func<T, U> success)
        {
            return success(value);
        }

        public IValidation<U, T> ToValidationT<U>()
        {
            return new ValidationMaybeT<U, T>(this, default(U));
        }

        private readonly T value;
    }

    public class None<T> : IMaybe<T>
    {
        public IMaybe<U> Select<U>(Func<T, U> f)
        {
            return new None<U>();
        }

        public IMaybe<U> SelectMany<U>(Func<T, IMaybe<U>> f)
        {
            return new None<U>();
        }

        public U Fold<U>(Func<U> error, Func<T, U> success)
        {
            return error();
        }

        public IValidation<U, T> ToValidationT<U>(U exceptionalValue)
        {
            return new ValidationMaybeT<U, T>(this, exceptionalValue);
        }
    }

    public class Customer
    {
        public Customer(string name)
        {
            Name = name;
        }

        public string Name { get; set; }
    }

    public interface IValidation<T, U>
    {
        IValidation<T, V> Select<V>(Func<U, V> f);

        IValidation<T, V> SelectMany<V>(Func<U, IValidation<T, V>> f);
    }

    public class ValidationError<T, U> : IValidation<T, U>
    {
        public ValidationError(T error)
        {
            Error = error;
        }

        public IValidation<T, V> Select<V>(Func<U, V> f)
        {
            return new ValidationError<T, V>(Error);
        }

        public IValidation<T, V> SelectMany<V>(Func<U, IValidation<T, V>> f)
        {
            return new ValidationError<T, V>(Error);
        }

        public T Error { get; private set; }
    }

    public class ValidationSuccess<T, U> : IValidation<T, U>
    {
        public ValidationSuccess(U value)
        {
            Result = value;
        }

        public IValidation<T, V> Select<V>(Func<U, V> f)
        {
            return new ValidationSuccess<T, V>(f(Result));
        }

        public IValidation<T, V> SelectMany<V>(Func<U, IValidation<T, V>> f)
        {
            return f(Result);
        }

        public U Result { get; private set; }
    }

    public class ValidationMaybeT<T, U> : IValidation<T, U>
    {
        public ValidationMaybeT(IMaybe<U> value, T error)
        {
            Value = value;
            Error = error;
        }

        public IValidation<T, V> Select<V>(Func<U, V> f)
        {
            return Value.Fold<IValidation<T, V>>(() => new ValidationError<T, V>(Error), s => new ValidationSuccess<T, V>(f(s)));
        }

        ValidationError<T, V> SelectManyError<V>()
        {
            return new ValidationError<T, V>(Error);
        }

        public IValidation<T, V> SelectMany<V>(Func<U, IValidation<T, V>> f)
        {
            return Value.Fold(() => SelectManyError<V>(), s => f(s));
        }

        public IMaybe<U> Value { get; private set; }

        public T Error { get; private set; }
    }

    public interface ICustomerRepository
    {
        IValidation<Exception, Customer> GetById(int id);
    }

    public class CustomerRepository : ICustomerRepository
    {
        public IValidation<Exception, Customer> GetById(int id)
        {

            if (id < 0)
                return new None<Customer>().ToValidationT<Exception>(new Exception("Customer Id less than zero"));

            return new Just<Customer>(new Customer("Structerre")).ToValidationT<Exception>();
        }
    }

    public interface ICustomerService
    {
        void Delete(int id);
    }

    public class CustomerService : ICustomerService
    {
        public CustomerService(ICustomerRepository customerRepository)
        {
            this.customerRepository = customerRepository;

        }

        public void Delete(int id)
        {
            customerRepository.GetById(id)
                .SelectMany(x => SendEmail(x).SelectMany(y => LogResult(y)));


        }

        public IValidation<Exception, Customer> LogResult(Customer c)
        {
            Console.WriteLine("Deleting: " + c.Name);
            return new ValidationSuccess<Exception, Customer>(c);
            //return new ValidationError<Exception, Customer>(new Exception("Unable write log"));
        }

        private IValidation<Exception, Customer> SendEmail(Customer c)
        {
            Console.WriteLine("Emailing: " + c.Name);
            return new ValidationSuccess<Exception, Customer>(c);
        }

        ICustomerRepository customerRepository;
    }

    [TestFixture]
    public class MonadTests
    {
        [Test]
        public void Testing_With_Maybe_Monad()
        {
            new CustomerService(new CustomerRepository()).Delete(-1);
        }
    }
}

另一个较小的子问题是，如果c有更高的类类型，我可以只实现一次这个类（validationt）并且它对所有其他包装的monad都有效，还是这不正确？

最佳答案

几乎，是最快的答案。您的ValidationMaybeT正在存储Maybe的值，而真正的monad转换器将具有Maybe和Validationmonad的行为，并且可以根据需要修改包装的monad的默认行为。
这是一个非常手动的方法，我不一定推荐，它变得非常混乱，非常迅速。缺乏更高的基因多态性会让你在任何机会都被绊倒。
我管理的最接近的（即使不是一个合适的monad转换器系统）是我的库：Language-Ext
项目中有13个monad（option、map、lst、one、try、reader等），我为它们实现了一组标准的函数：

Sum
Count
Bind
Exists
Filter
Fold
ForAll
Iter
Map
Select
SeletMany
Where
Lift

这些函数在函数式编程中是最有用的，并且几乎允许您执行所需的任何操作。
因此，随着所有monad实现这些标准函数，它们就变成了一种更高级的类型。不是编译器知道这一点，它们都只是同一“集合”的一部分。
然后我编写了一个t4模板来生成transformer函数作为扩展方法（它们有一个T后缀），用于“高级类型”中monad和function的每个组合。
例如：

var list = List(Some(1),None,Some(2),None,Some(3));
var total = list.SumT();

上面的代码导致6。SumT的定义是：

int SumT(Lst<Option<int>> self) =>
    self.Map( s => s.Sum() ).Sum();

FilterT例如，也可以在内部单子上工作：

var list = List(Some(1),None,Some(2),None,Some(3));
list = list.FilterT(x => x > 2);

所以扩展方法路由是一个很好的路由。不要创建新类型，请使用：

IValidation<IMaybe<T>>

然后提供Maybe的扩展方法。
你可以像我做的那样从标准集自动生成，或者手动编写它们。然后，它会保持IValidation<IMaybe<T>>和Maybe实现的干净，并将定制的转换器功能分开。
如果你感兴趣的话，这是我用来生成transformer方法的t4模板（老实说，这是非常不稳定的）：LanguageExt.Core/HKT.tt
这是生成的代码：LanguageExt.Core/HKT.cs
在我做上面的hkt之前，我做了一个类似于你所尝试的方法，我有一个叫做Validation的单子，它是一个TryOption<T>和一个Try。但有了新的香港电视节目，我现在可以写Option。最初的实现是here：
不管怎样，我希望这能有帮助！