C#中的Monad变形金刚

我正在使用C#中的monad变换器.
我想知道我提供的以下代码是否表明我已理解这一点.
我对此很新,所以任何反馈/评论都非常受欢迎.
此示例仅用于在验证monad中包装monad monad.

using System;
using NUnit.Framework;

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

            return new Just(value);
        }
    }

    public interface IMaybe
    {
        IMaybe Select(Func f);

        IMaybe SelectMany(Func> f);

        U Fold(Func error, Func success);
    }

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

        }

        public IMaybe Select(Func f)
        {
            return f(value).ToMaybe();
        }

        public IMaybe SelectMany(Func> f)
        {
            return f(value);
        }

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

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

        private readonly T value;
    }

    public class None : IMaybe
    {
        public IMaybe Select(Func f)
        {
            return new None();
        }

        public IMaybe SelectMany(Func> f)
        {
            return new None();
        }

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

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

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

        public string Name { get; set; }
    }

    public interface IValidation
    {
        IValidation Select(Func f);

        IValidation SelectMany(Func> f);
    }

    public class ValidationError : IValidation
    {
        public ValidationError(T error)
        {
            Error = error;
        }

        public IValidation Select(Func f)
        {
            return new ValidationError(Error);
        }

        public IValidation SelectMany(Func> f)
        {
            return new ValidationError(Error);
        }

        public T Error { get; private set; }
    }

    public class ValidationSuccess : IValidation
    {
        public ValidationSuccess(U value)
        {
            Result = value;
        }

        public IValidation Select(Func f)
        {
            return new ValidationSuccess(f(Result));
        }

        public IValidation SelectMany(Func> f)
        {
            return f(Result);
        }

        public U Result { get; private set; }
    }

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

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

        ValidationError SelectManyError()
        {
            return new ValidationError(Error);
        }

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

        public IMaybe Value { get; private set; }

        public T Error { get; private set; }
    }

    public interface ICustomerRepository
    {
        IValidation GetById(int id);
    }

    public class CustomerRepository : ICustomerRepository
    {
        public IValidation GetById(int id)
        {

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

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

    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 LogResult(Customer c)
        {
            Console.WriteLine("Deleting: " + c.Name);
            return new ValidationSuccess(c);
            //return new ValidationError(new Exception("Unable write log"));
        }

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

        ICustomerRepository customerRepository;
    }

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