can 'and!' be supported in async CE to wait on Async.StartChild

[Xyncgas]

async{
    let! aA= WorkA |> Async.StartChild
    let! aB= WorkB |> Async.StartChild
    let! A= aA
    let! B= aB
    return  A, B
}

nowadays noise increases with the amount of works I start as child, since I have to add let! x = aX for all of them

would be better if I could just

async{
    let! A= WorkA |> Async.StartChild
    and! B= WorkB |> Async.StartChild
    return  A, B
}

although and! is already taken, maybe we can add another keyword
(if I do I get this :

)

[jwosty]

It's already possible today to use the and! keyword to accomplish this, it's just not built in. Might be nice to have it in async natively. Not sure whether or not there's a suggestion for that already.

type AsyncBuilder with
    member this.MergeSources(m1: Async<'t1>, m2: Async<'t2>) : Async<'t1 * 't2> = async {
        let! m1' = Async.StartChild m1
        let! m2' = Async.StartChild m2
        let! m1'' = m1'
        let! m2'' = m2'
        return m1'', m2''
    }
    
let workA () = async {
    printfn "[A] Starting"
    for i in 0..10 do
        printfn "[A] i = %d" i
        do! Async.Sleep 100
    printfn "[A] done"
    return 42
}

let workB () = async {
    printfn "[B] Starting"
    for i in 0..10 do
        printfn "[B] i = %d" i
        do! Async.Sleep 75
    printfn "[B] done"
    return "supercalifragilisticexpialidocious"
}
    
let f () = async {
    let! a = workA ()
    and! b = workB ()
    printfn "A result: %d" a
    printfn "B result: %s" b
}

[vzarytovskii]

It's not in async because there's no agreement on how it should behave.

[Xyncgas]

Can you please enlighten me for what ideas people have for the behavior of and! and their argument for why

[Xyncgas]

If using @jwosty's implementation to do

async{
    let! A= WorkA
    and! B= WorkB
    and! C= WorkC
    return  A, B, C
}

does it only execute WorkA together with WorkB while executing WorkC seperately, or Work A / B / C executes together
is it waiting for Work A / B to finish (Async<ab>), while waiting for WorkC to finish (Async), or is it waiting for Async<ab*c> to finish

[SchlenkR]

in general:

• ‚let!‘ builds up a context of values (bound to identifiers), where each value can depend on the values already computed. Thus, the values cannot be computed independently from each other.
• ‚and!‘ builds a context of values, where each value can be computed independently from other values in the context.

[jwosty]

@Xyncgas Honestly I'm not completely sure; I would play around with it to figure out the exact behavior. Though I do know you can write more MergeSources overloads (i.e. one that takes 3 inputs, one that takes 4 inputs, etc) and the compiler will use them.

[bartelink]

Impl (in both cases) an be simplified to:

        let! m1' = Async.StartChild m1
        let! m2'' = m2
        let! m1'' = m1'

(which is what Async.Parallel kinda does)