How to use Validation applicative from F#

[glen-nicol]

I've been using this library with a lot of C# code and now was writing some F# to interface with that codebase and I'm having trouble calling some existing code that uses Validation<F,S>. Specifically I can't get the Prelude.Apply<F,A,B,R>( tuple of validations, func) extension to resolve in F# land. I even tried to make a little wrapper for it with all the explicit generics.

module Validation =
    open LanguageExt

    let apply<'F, 'A, 'B, 'R>
        (f: System.Func<'A, 'B, 'R>)
        struct (a: Validation<'F, 'A>, b: Validation<'F, 'B>)
        : Validation<'F, 'R> =
        let t = System.ValueTuple.Create(a, b)
        LanguageExt.Prelude.Apply<'F, 'A, 'B, 'R>(t, f)

Any help?

EDIT: oh I am on .Net 6 and F# 6 if that makes a difference.

[louthy]

Ok, so the short answer to your question is that you need to treat the Apply function as an extension method and not a static method:

let apply<'F, 'A, 'B, 'R>
    (f: System.Func<'A, 'B, 'R>)
    struct (a: Validation<'F, 'A>, b: Validation<'F, 'B>)
    : Validation<'F, 'R> =
    let t = System.ValueTuple.Create(a, b)
    t.Apply(f)

The longer answer is to define an operator that does this in a much better way.

First, I'll define the one and only wrapper needed for apply (and map):

let apply (mf : Validation<'f, 'a -> 'b>) (ma : Validation<'f, 'a>) : Validation<'f, 'b> =
    mf.Disjunction(ma)
      .Map(fun _ -> (successValue mf) (successValue ma))

let map (f : 'a -> 'b) (ma : Validation<'f, 'a>) : Validation<'f, 'b> =
    ma.Map(f)

I'm using the same Disjunction method that the original Apply extensions use.

To get the value out of the Validation monad we need to define the successValue function:

let successValue (ma : Validation<'f, 'a>) : 'a =
    ma.IfFail(fun () -> failwith "Validation monad is in a Fail state")

This can be done with explicit casts in C#, but this will have the same effect.

Next, let's create a couple of constructor functions for constructing a Validation monad:

let success x : Validation<'f, 'a> =
    Validation<'f, 'a>.Success(x)

let fail x : Validation<'f, 'a> =
    Validation<'f, 'a>.Fail(Prelude.Seq1(x))

And finally, the apply and map operators. I have used the same <*> operator as applicative-functors in Haskell:

let (<*>) = apply
let ($) = map

You can now easily apply:

let add = fun x y -> x + y
let mf = success add
let ma = success 123
let mb = success 456

let mr1 = mf <*> ma <*> mb
let mr2 = add $ ma <*> mb

Note how mr1 uses the lifted add function, whereas mr2 uses the lower add function and does a functor map rather than an applicative-functor apply.

I hope that helps. This is probably the one thing I wish I could do in C# (define operators that have different generics for each operand). Until then C# is stuck with tricks like the tuple extensions.

[louthy]

Here's a gist with the complete code

[glen-nicol]

Thanks Paul! I'm gonna have to spend some time to chew on the complete answer. Could you give me a short primer on Disjunction or some other equivalent terms for me to search and do some home work? My first google search seemed to be bringing up Disjunctive programming which I am not sure is related.

[louthy]

Logical disjunction is just logical 'or'.

https://en.m.wikipedia.org/wiki/Logical_disjunction

The disjunction method is the method that collects the errors if there's a failure - so a chain of Disjunction calls will collect all failures.

The following Map call is back to the classic sequential behaviour - so the lambda will only be called if there are no errors in the Disjunction chain.

However, the Disjunction method can't collect the success values (just the errors), so in the lambda passed to Map we need to cast the Validation values to their underlying success values (hence the successValue function).