Почему я НЕ получил ошибку отступа в моем коде golang?

Компилятор Go видит точки с запятой, вставленные токенизатором. Вам просто не обязательно их вводить, в «Спецификации языка программирования Go: точки с запятой» сказано:

Программы Go могут опускать большую часть этих точек с запятой [...]

[...] точка с запятой автоматически вставляется в поток токенов сразу после последнего токена строки, если этот токен

• идентификатор
• целочисленный, с плавающей запятой, мнимый, рунический или строковый литерал
• одно из ключевых слов break, continue, fallthrough или return
• один из операторов и знаков препинания ++, --, ), ] или }

[...] точка с запятой может быть опущена перед закрывающим ")" или "}"

Таким образом, эти точки с запятой автоматически вставляются токенизатором (который видит конец строки и может вставить точку с запятой). Вы увидите несколько точек с запятой в однострочных строках, но держу пари, что они встречаются редко (Go Playground):

package main

import "fmt"

func main() {
    world := func() string { name := "world"; return name }
    fmt.Println("Hello,", world())
}

Python использует логические строки:

Конец логической строки обозначается маркером NEWLINE. Операторы не могут пересекать границы логических строк, за исключением случаев, когда NEWLINE разрешен синтаксисом (например, между операторами в составных операторах).

Таким образом, токенизатор работает по-другому и NEWLINE является частью спецификации языка Python, хотя его нет в Go.

Почему фраза «[Go] использует символы новой строки для разделения операторов» неверна? Следующий код не компилируется (Go Playground):

package main

import "fmt"

func main() {
    a :=
        1
    b
        := 2
    fmt.Println(a, b)
}

сообщение ./prog.go:9:3: syntax error: unexpected :=, поэтому мы получаем ошибку := 2, а не a :=

Почему это? После того как токенизатор вставил точки с запятой, компилятор видит

func main() {
    a :=
        1;
    b;
        := 2;
    fmt.Println(a, b);
}

Итак, утверждение a := 1 верно, := 2 нет. Это не совсем понятно с «использованием новой строки для разделения операторов».

В нормальных обстоятельствах он предназначен для работы так, как ожидается, без необходимости тратить слишком много времени на размышления, но полезно понять, почему определенные конструкции работают (или не работают), например

func main() {
    a := 1
    b := 2
    fmt.
        Println(a, b)
}

быть действительным и

func main() {
    a := 1
    b := 2
    fmt
        .Println(a, b) // ❌
}

будучи недействительным.

В качестве патологического примера:

func main() {
    for
        i :=
            0
        i <
            5
        i++ {
            fmt.
                Println(
                    i,
                )
        }
}

действителен (Go Playground). В JavaScript это не так, поскольку правила там другие:

for (
  let
    i
    =
    0
    ;
    i
    <
    5
    ;
    i++
)
{
  console
    .
  log
    (
      i
    )
}

Иногда полезно использовать разрывы строк для форматирования кода в нужных местах, и они не обязательно приводят к автоматической вставке точки с запятой, если вы знаете правила.

Python использует пробелы (по крайней мере) двумя разными способами:

1. Он использует символы новой строки для разделения операторов.
2. Он использует отступы для обозначения тела блока.

#2 зависит от #1 — отступ зависит от символов новой строки, потому что вся концепция отступов заключается в том, что они идут в начале строки — но #1 не зависит от #2: мы можем представить язык, который использует символы новой строки для разделения операторы, но для обозначения тела блока используются фигурные скобки или другие обозначения.

. . . за исключением того, что нам даже не нужно это представлять, потому что, как вы заметили, Go — такой язык!

Другие подобные языки включают оболочки JavaScript и POSIX (например, Bash).

(Все эти языки также поддерживают точки с запятой для разделения операторов — вместо или вместе с символами новой строки — но одних символов новой строки достаточно.)