Return early with Error from Sequence mapping
I can't say, I have the full understanding of computation expressions, so here are some comments that may go in another direction than your purpose with the post:

sq |&gt; Seq.skip 1

can be replaced with
sq |&gt; Seq.tail


I'm not sure, I like that the function returns [ Error null ] for an empty sequence, but that again may be needed in the context? I would expect an empty sequence to return - an empty sequence.

I don't understand the Projection layer, but that may be dictated by the original context.
You could define the type at the function level:
type MaybeFunction&lt;'a, 'b, 'c&gt; = 
    | OptionFunction of ('a -&gt; 'b option)
    | ResultFunction of ('a -&gt; Result&lt;'b, 'c&gt;)

and then create the functions as:
let mbopFunction = OptionFunction (fun x -&gt; if x &lt; 5 then Some x else None)
let mbrsFunction = ResultFunction (fun x -&gt; if x &lt; 5 then Ok x else Error &quot;if &gt;= 5&quot;)

Your main function will then looks like:
let mapTillFail mapper s = 
    let rec inner sq =
        seq {
            let mapped = orb {
                let! head = Seq.tryHead sq
                match mapper with
                | OptionFunction a -&gt; 
                  let! m = a head
                  return m
                | ResultFunction a -&gt; 
                    let! m = a head
                    return m
                }                    
                                
            match mapped with
                | Error _ as err-&gt; yield err
                | Ok _ -&gt; 
                    yield mapped
                    yield! sq |&gt; Seq.tail |&gt; inner
        }
    inner s

which tells that your monad can handle that level without modifications.
Maybe it would be fair to call these function Projections as well as that is what they do?

That said, you can go without the computation expression:
let mapTillFail projection data = 

    let test x =
        let result = 
            match projection with
            | OptionProjection a -&gt; 
                match a x with
                | Some d -&gt; Ok d
                | None -&gt; Error Unchecked.defaultof&lt;'c&gt;
            | ResultProjection a -&gt; a x
        result

    let rec inner lst =
        seq {
            match lst |&gt; Seq.isEmpty with
            | true -&gt; yield Error Unchecked.defaultof&lt;'c&gt;
            | _ -&gt;
                match test (lst |&gt; Seq.head) with
                | Error e -&gt; yield Error e
                | Ok o -&gt;
                    yield Ok o
                    yield! inner (lst |&gt; Seq.tail)
        }

    inner data


Another alternative is to extent the MaybeProjection or MaybeFunction with a member called calculate:
type MaybeFunction&lt;'a, 'b, 'c&gt; = 
    | OptionFunction of ('a -&gt; 'b option)
    | ResultFunction of ('a -&gt; Result&lt;'b, 'c&gt;)
with
member this.Calculate (a) =
    match this with
    | OptionFunction f -&gt; 
        match f a with
        | Some d -&gt; Ok d
        | None -&gt; Error Unchecked.defaultof&lt;'c&gt;
    | ResultFunction f -&gt; f a

used as:
module Seq = 
    let mapTillFail (func: MaybeFunction&lt;'a, 'b, 'c&gt;) data =       
        
        let rec inner lst =
            seq {
                match lst |&gt; Seq.isEmpty with
                | true -&gt; ()
                | _ -&gt;
                    match func.Calculate (lst |&gt; Seq.head) with
                    | Error e -&gt; yield Error e
                    | Ok o -&gt;
                        yield Ok o
                        yield! inner (lst |&gt; Seq.tail)
            }

        inner data

Here I've made an extension to Seq so you can call it like any other Seq functions:
printfn &quot;%A&quot; ((r |&gt; Seq.mapTillFail mbopFunction) |&gt; Seq.toList)
printfn &quot;%A&quot; ((s |&gt; Seq.mapTillFail mbopFunction) |&gt; Seq.toList)
printfn &quot;%A&quot; ((r |&gt; Seq.mapTillFail mbrsFunction) |&gt; Seq.toList)
printfn &quot;%A&quot; ((s |&gt; Seq.mapTillFail mbrsFunction) |&gt; Seq.toList)