I was not familiar with the term, so I had to look it up. It's about code like this:

    a := b

the `:=` looks vaguely like a walrus. The most common reference language seems to be Python [1]. The usage is for making assignment remain an expression, so you can do stuff like

    area = (width := get_width()) * (height := get_height())

or something, and have the top-level expression remain valid since the sub-expressions are assignments that remain expressions, i.e. the assigned value is also the result of the expression.

[1]: https://realpython.com/python-walrus-operator/

Its also one of the more controversial features and its introduction sparked Guido's stepping down.

Since it was introduced, I have been looking but there has been only a handful of times where I could use it to write clearer code.

I'm curious if anyone actually likes it.

edit: A quick search shows that I do use it regularly in while loops, e.g.:

  while result := my_fun():
    ...

IIRC he stepped down because he thought it's a good feature and people pointlessly moaned about it. Not because he thought it's controversial and has enough.

I used it a small handful of times. But it also seems like quite a source of footguns. Many examples here: https://github.com/satwikkansal/wtfpython rely on the misuse of the walrus operator.

I have written Python since 2003 and used walrus only once. It's unnecessary.

Eh, I write a lot of Python and while it's unnecessary, it can make code easier to read if not overused.

  if (config_fn := base_dir / "config").exists():
      ...

is just a tiny bit shorter than this:

  config_fn = base_dir / "config"
  if config_fn.exists():
      ...

but if you do this enough times (if you are handling a lot of possible errors / missing data, etc.) it can definitely shorten the code.

If you have to wrap it in parens, it might be shorter but it's not really clearer.

In other contexts, parens are a good indication it's time for a new line.

But I can agree something like this does look clean and clear:

  if value := obj.get("key"):
      ...

python's use is the unusual one; the most common use (dating all the way back to algol) is to use it for assignment, so you can use = for equality.

https://en.wikipedia.org/wiki/Assignment_(computer_science)#...

Go uses "==" for equality checks, "=" for assignments, and ":=" for "declaration/assignment with type inference" - so it's different from both Python (you can use ":=" as part of an expression in Go too, but you can also use "=") and Algol/Pascal (where it's used only for assignment).

In math = is used for equality and := for definition[1] which is probably the closest thing to assignment in a programming language. That is why Pascal and similar languages use = for equality only and := for assignment.

That always made more sense to me than = for assignment and more =s for different kinds of equality, but in the end this syntax discussions are always just bike-shedding.