Question

您好我正在构建来自https://fsharpforfunandprofit.com/posts/elevated-world-3/的f＃示例在c＃。

我的代码如下，

 public class CustomerId : NewType<CustomerId, int> { public CustomerId(int id) : base(id) { } }

    public class EmailAddress : NewType<EmailAddress, string> { public EmailAddress(string email) : base(email) { } }

    public class Customer : Record<Customer>
    {
        public readonly CustomerId Id;
        public readonly EmailAddress Email;
        public Customer(CustomerId id, EmailAddress email)
        {
            Id = id;
            Email = email;
        }
    }

    public static class CustomerConstructor
    {
        public static Result<CustomerId> CreateCustomerId(int id)
        {
            if (id > 0) return new Result<CustomerId>.Success(new CustomerId(id));
            else return new Result<CustomerId>.Error(new[] { "invalid id" });
        }

        public static Result<EmailAddress> CreateCustomerEmail(string email)
        {
            if (string.IsNullOrEmpty(email)) return new Result<EmailAddress>.Error(new[] { "empty email" });
            else if (!email.Contains("@")) return new Result<EmailAddress>.Error(new[] { "invalid email" });
            else return new Result<EmailAddress>.Success(new EmailAddress(email));
        }
    }

    public abstract class Result<A>
    {
        public class Success : Result<A>
        {
            public readonly A Value;

            public Success(A value)
            {
                Value = value;
            }
        }

        public class Error : Result<A>
        {
            public readonly Arr<string> Errors;

            public Error(IEnumerable<string> errors)
            {
                Errors = errors.ToArr();
            }
        }

    }

public static class ResultModule
{
    public static UnitTest1.Result<A> Return<A>(this UnitTest1.Result<A> self, A a)
    {
        return new UnitTest1.Result<A>.Success(a);

    }

    public static UnitTest1.Result<A> Return<A>(A a)
    {
        return new UnitTest1.Result<A>.Success(a);

    }

    public static UnitTest1.Result<B> Select<A, B>(this UnitTest1.Result<A> self, Func<A, B> map)
        => Map<A, B>(self, map);

    public static UnitTest1.Result<B> Map<A, B>(this UnitTest1.Result<A> self, Func<A, B> map)
    {
        if (self is UnitTest1.Result<A>.Success)
        {
            var sx = (UnitTest1.Result<A>.Success)self;
            return new UnitTest1.Result<B>.Success(map(sx.Value));
        }
        else
        {
            var er = (UnitTest1.Result<A>.Error)self;
            return new UnitTest1.Result<B>.Error(er.Errors);
        }
    }

    public static UnitTest1.Result<B> ApplyMine<A, B>(this UnitTest1.Result<A> self, UnitTest1.Result<Func<A, B>> apply)
    {
        if (apply is UnitTest1.Result<Func<A, B>>.Success && self is UnitTest1.Result<A>.Success)
        {
            var f = (UnitTest1.Result<Func<A, B>>.Success)apply;
            var x = (UnitTest1.Result<A>.Success)self;

            return new UnitTest1.Result<B>.Success(f.Value(x.Value));
        }

        if (apply is UnitTest1.Result<Func<A, B>>.Error && self is UnitTest1.Result<A>.Success)
        {
            var f = (UnitTest1.Result<Func<A, B>>.Error)apply;
            return new UnitTest1.Result<B>.Error(f.Errors);
        }

        if (apply is UnitTest1.Result<Func<A, B>>.Success && self is UnitTest1.Result<A>.Error)
        {
            var x = (UnitTest1.Result<A>.Error)self;
            return new UnitTest1.Result<B>.Error(x.Errors);
        }

        if (apply is UnitTest1.Result<Func<A, B>>.Error && self is UnitTest1.Result<A>.Error)
        {
            var f = (UnitTest1.Result<Func<A, B>>.Error)apply;
            var x = (UnitTest1.Result<A>.Error)self;
            return new UnitTest1.Result<B>.Error(f.Errors.Concat(x.Errors));
        }

        return default(UnitTest1.Result<B>);//fn should never hit here
    }

    public static UnitTest1.Result<B> Bind<A, B>(this UnitTest1.Result<A> self, Func<A, UnitTest1.Result<B>> bind)
    {
        if (self is UnitTest1.Result<A>.Success)
        {
            var sx = (UnitTest1.Result<A>.Success)self;
            return bind(sx.Value);
        }
        else
        {
            var er = (UnitTest1.Result<A>.Error)self;
            return new UnitTest1.Result<B>.Error(er.Errors);
        }
    }

    public static UnitTest1.Result<C> SelectMany<A, B, C>(this UnitTest1.Result<A> self, Func<A, UnitTest1.Result<B>> bind, Func<A, B, C> project)
    {
        var bound = Bind<A, B>(self, bind);
        if (bound is UnitTest1.Result<B>.Success)
        {
            var sxA = (UnitTest1.Result<A>.Success)self;
            var sxB = (UnitTest1.Result<B>.Success)bound;
            return new UnitTest1.Result<C>.Success(project(sxA.Value, sxB.Value));

        }
        else
        {
            var er = (UnitTest1.Result<A>.Error)self;
            return new UnitTest1.Result<C>.Error(er.Errors);
        }
    }
}

注意：UnitTest1是添加的命名空间（因为LanguageExt中有Result类型）

上面的代码我的测试如下

[TestMethod]
public void TestApplicativeValidation()
{
    var goodId = 1;
    var badId = 0;
    var goodEmail = "test@example.com";
    var badEmail = "example.com";

    Func<CustomerId, EmailAddress, Customer> createCustomer = (id, email) => new Customer(id, email);
    var idResult = CustomerConstructor.CreateCustomerId(goodId);
    var emailResult = CustomerConstructor.CreateCustomerEmail(goodEmail);
    var createCustomer1 = ResultModule.Return(createCustomer);

    //ResultModule.ApplyMine(idResult, )




}

[TestMethod]
public void TestMonadaicValidation()
{
    var goodId = 1;
    var badId = 0;
    var goodEmail = "test@example.com";
    var badEmail = "example.com";

    var goodCust = from id in CustomerConstructor.CreateCustomerId(goodId)
                   from email in CustomerConstructor.CreateCustomerEmail(goodEmail)
                   select new Customer(id, email);

    var badCust = from id in CustomerConstructor.CreateCustomerId(badId)
                  from email in CustomerConstructor.CreateCustomerEmail(badEmail)
                  select new Customer(id, email);

}

Monadiac测试运行时已经完成并且全部找到了，但是我无法编写测试来检查链接中的应用场景，

let (<!>) = Result.map
let (<*>) = Result.apply

// applicative version
let createCustomerResultA id email = 
    let idResult = createCustomerId id
    let emailResult = createEmailAddress email
    createCustomer <!> idResult <*> emailResult
// int -> string -> Result<CustomerInfo>

任何人都能指导我在这里提出一些见解，我们有一个linq表达式自动使用select / select many，在应用样式的情况下是什么？

Answer 1

您正在寻找language-ext中的Validation类型来实现该示例。我不会为你完成所有的工作，但是你可以看看one of the units tests，它有一个使用Validation类型的应用行为的真实示例。

language-ext中的大多数核心类型都支持应用行为through the apply function。

Answer 2

我在上面找到了正确的ApplyMine函数实现。以下是申请的测试案例。

  [TestMethod]
        public void TestApplicativeValidation()
        {
            var goodId = 1;
            var badId = 0;
            var goodEmail = "test@example.com";
            var badEmail = "example.com";

            Func<CustomerId, EmailAddress, Customer> createCustomer = (id, email) => new Customer(id, email);

            /*
            var idResult = CustomerConstructor.CreateCustomerId(goodId);
            var emailResult = CustomerConstructor.CreateCustomerEmail(goodEmail);
            var goodCustomer = idResult.Lift2(emailResult, createCustomer);
            */

            var good = CustomerConstructor.CreateCustomerId(goodId).Lift2(CustomerConstructor.CreateCustomerEmail(goodEmail), createCustomer);

            var bad22 = CustomerConstructor.CreateCustomerId(badId).Lift2(CustomerConstructor.CreateCustomerEmail(badEmail), createCustomer);

            var bad1 = CustomerConstructor.CreateCustomerId(goodId).Lift2(CustomerConstructor.CreateCustomerEmail(badEmail), createCustomer);

            var bad2 = CustomerConstructor.CreateCustomerId(badId).Lift2(CustomerConstructor.CreateCustomerEmail(goodEmail), createCustomer);


        }

以下是添加到扩展类/模块的Lift2实现。

 public static UnitTest1.Result<C> Lift2<A, B, C>(this UnitTest1.Result<A> self, UnitTest1.Result<B> other, Func<A, B, C> lift2)
        {
            Func<A, Func<B, C>> lifter = a => b => lift2(a, b);

            var aBakedIn = self.ApplyMine(ResultModule.Return(lifter));
            return other.ApplyMine(aBakedIn);
        }

在csharp中，没有表达式的应用风格编程，对于monadiac风格我们有linq

  var goodCust = from id in CustomerConstructor.CreateCustomerId(goodId)
                           from email in CustomerConstructor.CreateCustomerEmail(goodEmail)
                           select new Customer(id, email);

，使用2个monad和2个参数函数显式调用lift2会更简洁。就像语言 - ext通过Prelute一样。我决定按照＃34;点入符号＆＃34;在使用功能构造时也很敏锐。

当我进行脑力训练时，这篇文章开始拯救！ http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

Language-Ext，如何在c＃中使用applicatives？

2 个答案: