Go's new small language features from 1.22 and 1.23 are nice
Recently I was writing some Go code involving goroutines. After I was done, I realized that I had
used some new small language features added in Go 1.21 and Go 1.22, without really thinking about
it, despite not having paid much attention when the features were
added. Specifically, what I used are the new builtins of max()
and min()
, and 'range over integers' (and also a use of clear()
,
but only in passing).
Ranging over integers may have sounded a bit silly to me when I first read about it, but it turns out that there is one situation where it's a natural idiom, and that's spawning a certain number of goroutines:
for range min(maxpar, len(args)) { wg.Add(1) go func() { resolver() wg.Done() }() }
Before Go 1.21, I would have wound up writing this as:
for i := 0; i < maxpar; i++ { [...] }
I wouldn't have bothered writing and using the function equivalent of
min()
, because it wouldn't be worth the extra hassle for my small
scale usage, so I'd always have started maxpar
goroutines even if some
of them would wind up doing nothing.
The new max()
and min()
builtins aren't anything earthshaking,
and you could do them as generic functions, but they're a nice
little ergonomic improvement in Go. Ranging over integers is something
you could always do but it's more compact now and it's nice to
directly see what the loop is doing (and also that I'm not actually
using the index variable for anything in the loop).
(The clear()
builtin is nice, but it also has a good reason for
existing. I was only using it on a slice,
though, where you can fully duplicate its effects.)
Go doesn't strictly need max()
, min()
, and range over integers
(although the latter is obviously connected to ranging over functions,
which is important for putting user container types closer to par
with builtin ones). But adding them
makes it nicer, and they're small (although growing the language
and its builtins does have a quiet cost), and Go has never presented
itself as a mathematically minimal language.
(Go will have to draw the line somewhere, because there are a lot of little conveniences that could be added to the language. But the Go team is generally conservative and they're broadly in a position to not do things, so I expect it to be okay.)
|
|