Single operator for railway oriented programming

[Xyncgas]

imagine you have an unknown amount of Async inside Async, with the final type inside async being Async<'b voption> seq, now imagine a single operator to bind it to a function that works with 'b seq

in my opinion that's doable via insane operator overload, or maybe if fsharp language supports 'marking' a convertor that gives you what's useful, for example Some in Option and 'a in Async<'a>, with this information we can have an operator that always let you work on what's useful

Alternatively, because you might want to control how Async<'a> seq is enumerated, maybe in parallel maybe in single thread, let is enable building such operator by binding 'rules' together from the fsharp core library

so such operator can be built for example :

let rule_1 = Async.OperatorRules.ShouldConcat >> Async.OperatorRules.ShouldParallel
let rule_2 = Seq.OperatorRules.ShouldEval >> ValueOption.OperatorRules.ShouldEval
let inline (>>) = rule_1 >> rule_2

now you are always working with what's useful in the binding function

[Xyncgas]

Another way I can do this I want to share is having a mini operator language :
| for Async
? for option
* for seq

now people can write

let newobj (f : b -> c) = old |????|*|*|> f

and because we had concat functions already for options (which is ??>)

I can use the operator in my code today by implementing it myself, it will be reusable for similar situations, but the sourcegen can generate |????|*|*|> operator even though it's not defined by the fsharp core lib, but because fsharp corelib has reduction rules and fsharp supports this mini language we can write |????|*|*|> and it's going to become |?|*|*|> and because, idk, some how it can binds to 'b -> 'c

although letting people write |????|*|*|> without defining what it is, is an improvement for me, I am dreaming about an operator that can replace all (binding) operator, the supreme operator, the ultima, that can take anything and bind to 'b -> 'c where b is not some Async<Async<Async<'a seq> voption seq>voption seq voption option> but simply 'a, where c is not a bunch things but simply Async<'a seq>

My thought is ultimately reducing noise for monad and making the experience of writing monad better, for people to enjoy an expressiveness monad brings