Why would I want to use the upcoming let! ... and! syntax?

Question

The language suggestion states that the advantages are detailed in the linked paper. I had a quick skim through and I can't see it spelled out explicitly.

Is the advantage just that each statement gets executed in parallel so I might get a speed boost? Or is there some kind of logic it caters for, that is not convenient using the usual monadic let!?

I understand that, this being applicative, means that it comes with the limitation that I can't use previous expressions to determine the logic of subsequent expressions. So does that mean the trade off is flexibility for efficiency?

Answer 1

The way I understood Don Syme's description, when I read it a while ago, was every step in the let! ... and! ... chain will be executed, unlike when you use let! ... let! .... Say, for instance, that you use the option CE. Then if you write

option {
    let! a = parseInt("a")
    let! b = parseInt("b")
    return a + b
}

only the first let! will be executed, as the CE short-circuits as soon as it meets a None. Writing instead let! a ... and! b = ... will try to parse both strings; though not necessarily in parallel, as I understand it.

I see a huge benefit in this, when parsing data from external sources. Consider for instance running

parse {
    let! name = tryParse<Name>("John Doe")
    and! email = tryParse<EMail>("johndoe@")
    and! age = tryParse<uint>("abc")
    return (name, email, age)
}

and getting an Error(["'johndoe@' isn't a valid e-mail"; "'abc' isn't a valid uint"]) in return, instead of only the first of the errors. That's pretty neat to me.