Early return syntax

[konst-sh]

Though F# is known for not having early returns it actually is capable for this using if then else or match expressions when in the first branch the short path returns and in the second the - the longest. From the user point the long execution path might doesn't even look like being in the scope of the else branch or last variant of match which saves the indentation level.

let f(x: Result<int, string>) =
    match x with 
    | Error _ -> x 
    | Ok i ->
    //Note that if we rewrite the upper in one row like `match x with Error _ -> x | Ok i -> ` it will not compile

    printfn "Should be OK"
    Ok i

Given that F# encourages functional practices but does not provide builtin computation expressions for Result and Option types and that computation expressions of different types are poorly combined with one another and also keeping in mind the successful usage of similar unwrapping syntaxes or special kind of bindings in Rust and Ocaml may we speculate about bringing similar type of syntax in F#?
I imagine that could be in form of the special static method, similar to active pattern that maps the container value into two variants - for short and long return paths and exposes the value from long path for the downstream scope.
The declaration can be like:

module Result =
    let bindOk! (res: Result<'t, 'e>) =
        match res with
        | Ok r -> Some r // the r value from this branch will be exposed
        | _ -> None //All other variants of `res` are desugared to short return paths

On the usage side:

let f(x: Result<int, string>) =
   //one way I can think of is something like this:
    x |> Result.bindOk! i // The i value is exposed for downstream scope
   //another is similar to let binding:
   Result.bindOk! i = x
    
    printfn "Should be OK"
    Ok i

[abelbraaksma]

the long execution path might doesn't even look like being in the scope of the else branch or last variant of match which saves the indentation level.

Indeed, which is why this type of coding is typically a bad idea. Use Fantomas or similar means to prevent accidental outdented code. It would be good if the compiler could raise a warning here.

may we speculate about bringing similar type of syntax in F#

what syntax are you talking about? You mention CEs not being present for Result and Option (but you can write them, or use a NuGet package). Other than that I don't see what you are asking here.

for short and long return paths and exposes the value from long path for the downstream scope.

Sorry, you lost me here. The "long return path" as you call it, was just badly indented. Your code should look like this when properly formatted:

let f(x: Result<int, string>) =
    match x with 
    | Error _ -> x 
    | Ok i ->
        printfn "Should be OK"
        Ok i

If you don't write the code properly, there's no clear telling from reading the code, what the scope is. To prevent such errors, tools like Fantomas exist. I can highly recommend it.

In the last example, you seem to suggest to use bang-syntax in non-CE code. However, that's a major syntactical change with, I think, little to no benefit. You can use that syntax inside a CE, though.

I'm not quite sure what you are trying to achieve here and what Early return syntax is, as I don't see code that returns early (and I apologize if I totally miss your point with my comment above).