Yep. When I realized this I was so weirded out I went on the Gleam discord and asked “is… is this on purpose? You guys know what you’ve done, right? Are you going to use this for general coroutines or something?” The answer was basically “yeah we know, it’ll probably get used for other things someday but for now we’re mostly just interested in error handling”.

Half the thread on the introduction of use expressions was how they’re equivalent to dot expressions.

Would even be better if they did in the state-of-the-art way. E.g. https://github.com/dsyme/dsyme-presentations/blob/master/design-notes/ces-compared.md or also similar to how Haskell/Scala do it.

It’s interesting how Roc and Gleam are going different ways. We used to have a specific try and then moved to the general use.

Would this cover the await syntax transformation too? Suppose I had something like a Promise and wanted to chain together .then calls (with rejects automatically bailing early).

Yep! You can think of use as a generalization of the await transformation. When targeting JS, promise.await takes a callback as its last argument so you can use it like so

use user <- promise.await(get_user())
use posts <- promise.await(get_posts(user))
display_posts(posts)

Much like await in JS, the return value of this block would itself be a promise.

Given the number of very complex features of other languages Gleam has side-stepped with one syntax sugar I think it has been a tremendous success!

But many instances of use don’t function that way–they will always (practically) call the callback.

The majority of use is for monadic APIs in which the callback is called conditionally. It’s uncommon for the callback to always be called.

It does yes, and if you rewrite the example to not use the use sugar, you can see more clearly how it’d work.

fn catify_with_use(strings: List(String)) -> List(String) {
  list.map(strings, fn(string) {
    string <> " cat"
    debug("hi")
  })
}

So calling catify_with_use(["wibble", "wobble"]) will result in "hi" being printed twice, and the returned list being ["hi", "hi"] as the last expression is debug("hi") (it prints its argument then returns it).

To anticipate another question you may have: as I understand the article, to limit the scope of use you enclose it in a block. (No computer at hand, so not tested, sorry.)

fn catify_with_use(strings: List(String)) -> List(String) {
  let old_possums_cats = {
    use string <- list.map(strings)
    string <> " cat"
  }
  debug("hi")
  old_possums_cats
}

catify_with_use(["jellicle", "dramatical"])
// debug called once
// returns ["jellicle cats", "dramatical cats"]

From the Gleam docs, this is just syntactic sugar for the following. This code

use a <- foo
example(a)
use b, c <- bar(a)
example(b, c)

is equivalent to this

foo(fn(a) {
  example(a)
  bar(a, fn (b, c) {
    example(b, c) 
  })
})

the variables extracted with the “use” are just the values you would get if passing a callback as last argument.

Yeah, I probably would use it for list.map myself. I think the conventional callback syntax is clearer in that case.