Add if! (if-bang) keyword to computation expressions

[jwosty]

Add if! (if-bang) keyword to computation expressions

I propose we extend computation expressions with a new keyword, if! (if-bang), that functions a let! (let-bang) combined with an if statement. For example, instead of writing:

let! shouldSolveWorldHunger = confirmAsync ("Solve world hunger?")
if shouldSolveWorldHunger then solveWorldHunger () else dont ()

or even:

match! confirmAsync("Solve world hunger?") with
| true -> solveWorldHunger ()
| false -> dont ()

We should be able to do:

if! confirmAsync("Solve world hunger?") then
    solveWorldHunger ()
else dont ()

Pros and Cons

Pros: Aids code readability in specialized cases.

Cons: It's work, and it increases complexity. (whether or not this is worth the effort for potentially such small return is up to debate / whoever would do it, but I figure it's worth filing [probably low priority :) ] since I am not aware of a prior suggestion -- would be brownie points for the F# language)

Extra information

S

Related suggestions: (put links to related suggestions here)

#572

Affidavit (please submit!)

Please tick this by placing a cross in the box:

• This is not a question (e.g. like one you might ask on stackoverflow) and I have searched stackoverflow for discussions of this issue
• I have searched both open and closed suggestions on this site and believe this is not a duplicate
• This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:

• This is not a breaking change to the F# language design
• I or my company would be willing to help implement and/or test this

[dsyme]

This seems reasonable

[nikonthethird]

Should that include elif! as well?

let x = async {
    if! asyncBool then
        do! task1
    elif! anotherAsyncBool then
        do! task2
    else
        do! task3
}

[yatli]

@nikonthethird probably yes, and pretty effortless, since elif! = else if!

[realvictorprm]

Good catch, that's really quite reasonable! :3

[mvkara]

It would be good to consider other typical branching constructs as well; in particular the "while" keyword. A good use case would be using ADO.NET; not sure if this is already supported. Normally you would need a recursive function to do this - would be much easier with .

asyncSeq {
    // https://docs.microsoft.com/en-us/dotnet/api/system.data.common.dbdatareader.readasync?view=netcore-3.1
    while! reader.MoveNextAsync() do
        yield {| Column1 = reader.GetInt32(0); Column2 = reader.GetInt32(1) |}
}

[Tarmil]

@mvkara There's a major difference between while! (and for! I guess) on one hand, and match! and if! on the other.

• match! and if! are just syntactic sugar: they're equivalent to let! followed by the corresponding keyword. So they don't require adding anything to the CE, as soon as they're added to the language they're usable with any CE.

• while!'s condition is not evaluated just once, so it's not so simple. It would need to be implemented explicitly by a CE (presumably as a method WhileFrom).

So I think it's a good idea but probably belongs in a separate suggestion.

[yatli]

I agree with @Tarmil -- plus that it's likely these constructs should be designed to incorporate with IAsyncEnumerable

[Lanayx]

Wanted to add one more comment for discussion, not directly related to the topic, but not sure where to put it - it would be nice to support bang operations inside if without overhead of raising 0 to async:

async {
    let result = 
        if condition then
            let! x = doSmthAsyncReturningInt()
            x
        else
            0
    return result
}

this can be easily done in C#, but not F#:

var result = condition ? await doSmthAsyncReturningInt() : 0;

[nikonthethird]

It is actually possible to implement a while! today by adjusting the async expression builder. You just have to add another overload for while that accepts an asynchronous guard:

type AsyncBuilder with
    member this.While (guard, body) =
        let guard = guard ()
        let rec loop = function
        | false -> this.Zero ()
        | _ -> this.Combine (body, this.Bind (guard, loop))
        this.Bind (guard, loop)
    

Async.RunSynchronously (async {
    let mutable count = 5
    while async { return count > 0 } do
        do printfn "Counting down: %d" count
        do count <- count - 1
})

[Tarmil]

@Lanayx The problem in your code isn't the if actually; it's that you're putting a let! inside the definition part of a let, which means it's not part of the CE anymore. See for example:

// This does NOT work, even without an if, because there's a let! inside a let:
async {
    let sum =
        let! x = someAsyncCode()
        x + y
    return sum * 2
}

// This DOES work, even with the if:
async {
    if someCondition() then
        let! x = someAsyncCode()
        return x + y
    else
        return y * 2
}

[Lanayx]

@Tarmil Thanks for the explanation! However as you can see, the problem is not in my code, but in this nested limitation - C# doesn't have such limitation and it would be nice not to have it in F# either.

[yatli]

@Lanayx I think I understand the problem. But having different types on if-else branches feel wrong to me.

[Lanayx]

@yatli this is very helpful for caching scenarios - if local cache exists return cached value, otherwise make async call. To go over this limitation I had to use mutable variable