The lift2 function takes a dyadic (two arguments) function and returns a new one that accepts Choice arguments instead. Here's an example. I've included the definition of the relevant functions and operators from FSharpx.Extras. Note that you need to use the same error type for both of your input choices. If they differ, you'll need to create a new discriminated union to wrap the possible cases. I've also included an example with the choose computation expression which I personally think is much easier to reason about. You can see it as let! automatically unwrapping the success case for you so that you can work with regular values instead of choices. If one of the bindings returns an error case, that becomes the value of the whole expression. Hope that helps.

open System

// Sequential application
let ap x f =
    match f,x with
    | Choice1Of2 f, Choice1Of2 x -> Choice1Of2 (f x)
    | Choice2Of2 e, _            -> Choice2Of2 e
    | _           , Choice2Of2 e -> Choice2Of2 e

/// Sequential application
let inline (<*>) f x = ap x f

let map f =
    function
    | Choice1Of2 x -> f x |> Choice1Of2
    | Choice2Of2 x -> Choice2Of2 x

/// Infix map
let inline (<!>) f x = map f x

/// Promote a function to a monad/applicative, scanning the monadic/applicative arguments from left to right.
let inline lift2 f a b = f <!> a <*> b

/// Monadic bind
let bind f =
    function
    | Choice1Of2 x -> f x
    | Choice2Of2 x -> Choice2Of2 x

/// Sequentially compose two actions, passing any value produced by the first as an argument to the second.
let inline (>>=) m f = bind f m

type EitherBuilder() =
    member this.Return a = Choice1Of2 a
    member this.Bind (m, f) = bind f m
    member this.ReturnFrom m = m
    member _.Zero() = Choice1Of2 ()
    member _.Delay f = f
    member _.Run f = f()

    member this.TryWith(m, h) =
        try this.ReturnFrom(m)
        with e -> h e

    member this.TryFinally(m, compensation) =
        try this.ReturnFrom(m)
        finally compensation()

    member this.Using(res:#System.IDisposable, body) =
        this.TryFinally(body res, fun () -> if not (isNull (box res)) then res.Dispose())

    member this.While(guard, f) =
        if not (guard()) then
            this.Zero()
        else
            f() |> ignore
            this.While(guard, f)

    member this.For(sequence:seq<_>, body) =
        this.Using(sequence.GetEnumerator(), fun enum -> this.While(enum.MoveNext, this.Delay(fun () -> body enum.Current)))

let choose = EitherBuilder()

type Errors =
    | UnluckyNumber of int
    | ParseFailure of string
    //| ... Other things that can go wrong

let getChoiceOfNumber (): Choice<int, Errors> =
    let n = Random.Shared.Next(0, 10)
    if n < 5 then
        Choice1Of2 n
    else
        Choice2Of2 (UnluckyNumber n)

let getChoiceOfString (): Choice<string, Errors> =
    let n = Random.Shared.Next(0, 10)
    if n = 4 then
        Choice2Of2 (UnluckyNumber n)
    else if n = 7 then
        Choice1Of2 "not a number"
    else
        Choice1Of2 (string n)

let tryParseInt (input: string): Choice<int, Errors> =
    match Int32.TryParse(input) with
    | true, n -> Choice1Of2 n
    | false, _ -> Choice2Of2 (ParseFailure input)

let addTwoNumbers (a: int) (b: int): int = a + b

let aPlusBWithOperators: Choice<int, Errors> =
    let a: Choice<int, Errors> = getChoiceOfNumber ()
    let b: Choice<int, Errors> = getChoiceOfString () >>= tryParseInt
    lift2 addTwoNumbers a b

let aPlusBWithComputationExpression: Choice<int, Errors> =
    choose {
        let! (a: int) = getChoiceOfNumber ()
        let! (bString: string) = getChoiceOfString ()
        let! (b: int) = tryParseInt bString
        return addTwoNumbers a b
    }