How can you make an Option.bind but for bool returns from an imperative library?

How do you do a bind-type operation with boolean results, then switch over to an F# style pipe workflow? I don't understand why the compiler complains when I switch from the "continue if to true" |>> to using a standard pipe at the end. The output of doSomething1 isn't being passed to |>>, so why does it care what its type is?

//Function style for an imperative library.
//y is an outref but defined as byref<'T>. You 
//have to define a mutable var to get the 
//output. You can't use: let boolRes, y = CreateY x
let CreateY (x, y: byref<'T>) = 
    if x > 0 then 
        y <- x
        true
    else false

//My code
//Continue If True
//I can't get this to work
let (|>>) f b =
    match b with
    | true -> f
    | false -> false

//Once I get all my parameters, I can do my own f#
//style things.  
let doSomething1 y1 y2 y3 = 
    let y4: int = y1 + y2 + y3
    printfn "I get a %i and a %i and a %i and now I can make %i" y1 y2 y3 y4
    y4

let doSomething2 y4 = 
    let y5: int = y4 * 2
    y5

let whyWontThisWork () = 
    let mutable y1 = 0
    let mutable y2 = 0
    let mutable y3 = 0

    CreateY(0, &y1)
    |>> CreateY(2, &y2)
    |>> CreateY(3, &y3)
    |>> doSomething1 y1 y2 y3 //expected to have type bool?
    |> doSomething2 //expecting a bool -> a???

If you're willing to use options, I think this can be done elegantly using a computation expression:

let CreateY (x, y: byref<int>) = 
    if x > 0 then 
        y <- x
        true
    else false

type Builder() =
    member _.Return(value) = Some value
    member _.ReturnFrom(opt : Option<_>) = opt
    member _.Bind(b, f) = if b then f () else None
    member _.Zero() = None

let build = Builder()

let doSomething1 y1 y2 y3 = 
    let y4: int = y1 + y2 + y3
    printfn "I get a %i and a %i and a %i and now I can make %i" y1 y2 y3 y4
    y4

let doSomething2 y4 = 
    let y5: int = y4 * 2
    y5

let thisWillWork x = 
    let mutable y1 = 0
    let mutable y2 = 0
    let mutable y3 = 0

    build {
        do! CreateY(x, &y1)
        do! CreateY(2, &y2)
        do! CreateY(3, &y3)
        return doSomething1 y1 y2 y3
            |> doSomething2
    }

thisWillWork 1 |> printfn "%A"   // Some 12
thisWillWork 0 |> printfn "%A"   // None

The key line is:

    member _.Bind(b, f) = if b then f () else None

Just to show what's going on, this desugars to:

    build.Bind(CreateY(x, &y1), fun () ->
    build.Bind(CreateY(2, &y2), fun () ->
    build.Bind(CreateY(3, &y3), fun () ->
    doSomething1 y1 y2 y3
        |> doSomething2
        |> Some)))