On: Go 1.13 Release Notes

[zubspace]

I know. The question is, why does it need a colon? It seems completely superfluous, from a syntax perspective.

[sacado2 → zubspace]

It's to avoid typos. Imagine there is no colon. When you type

    foo = 3
    fooo = foo + 1

Did you mean to create a new variable called `fooo` or was it a typo? Did you mean this:

    foo := 3
    fooo = foo + 1 // oops, typo found at compile-time

or that:

    foo := 3
    fooo := foo + 1 // Yep, new var, everything is ok

[philliphaydon → sacado2]

Why not just have

var foo = 1

[masklinn → philliphaydon]

That works actually.

The weirdness is that ":=" allows redeclaration (within a scope) but only partial, whereas `var` completely forbids redeclaration.

That is:

    var a, b = f()
    var a, b = f() // NO

    var a, b = f()
    a, b := f() // NO

    
    // note that the second declaration only partially overlaps with the first
    var a, b = f()
    var a, c = f() // NO

    var a, b = f()
    a, c := f() // yes

[zchrykng → zubspace]

I think the point is to make sure you know what you are doing. That declaring a new variable should always be an intentional act, and this makes assignments to typoed variable names error rather than just creating a new variable.

[zemo → zubspace]

it's not. Go has block-level scoping. = means "assign the existing identifier to this value". := means "create a new identifier".

https://play.golang.org/p/Irqxm0okfkt

[zubspace → zemo]

Thanks for the example. In all my life I never actually wanted to do something like this, but well... It's neat that go allows this.

[naikrovek → zubspace]

You will if you ever do concurrency stuff in go. The way goroutines capture their working variables in a closure make things like `x := x` useful and clear (once you know why you do it in the first place )

[zemo → zubspace]

that's likely not true. Every time you do this:

    if err := fn(); err != nil {
    }
    // the result of fn does not affect the identifier err
    // in the enclosing scope

you're scoping err just to that if block. that's ... just about the most common phrase in all of Go. it won't affect any err defined prior and it won't exist outside of the if block.

You'd have to do this to make the value stick around or affect the enclosing block:

    var err error
    if err = fn(); err != nil {
    }
    // err has the result of fn here

[pkaye → zubspace]

It catches some coding errors due to mispelling. Did you mispell an existing variable or wanted to declare a new one.