While watching Richard Feldman's talk on the Roc programming language, I came across an interesting bit of syntax sugar around chaining effects he calls "backpassing". Backpassing is sugar around passing a "callback" type function to another function. In Oak syntax, it lets us rewrite a program like

with fs.readFile('/etc/hosts') fn(file) {
	std.println(file)
}

... into this

// Roc uses `<-`, but since `<-` means something
// in Oak, we use `:= await` here instead, where
// "await" is a new language keyword.
file := await fs.readFile('/etc/hosts')
std.println(file)

It's pure sugar -- it desugars at the parser stage, which is clever and different than other implementations of await that depend on some Promise or Future type in the core language. Its advantage is that it relieves the indentation hell of passing callbacks at a pure syntax level. Its disadvantage is that there's no visible function literal in the program anymore, and I imagine compile errors it generates won't be pretty. This is a bit of invisible syntax magic, which is generally against my (and hence Oak's) philosophy of simplicity promoting understandability.

Nonetheless, I'll be mulling it over and lightly considering it for Oak.