Technical reasons behind Go's strange syntax

I recently started learning to Go, and I am quite confused as to why it has a strange "non-traditional" syntax unlike other languages (C, C++, C#, JAVA)

For example, a code like this in Go:

package main

import "fmt"

func sum(a int, b int) int {
	return a + b
}

func main() {
	numbers := [4] int {1, 2, 3, 4}

	for _,n := range numbers {
		result := sum(n, 2)
    	fmt.Println(result)
	}
}

But, could be written something like in some languages:

package main

import "io"

int sum(int a, int b) {
    return a + b
}

void main() {
    int numbers[4] = {1, 2, 3, 4}
    
    foreach (n in range(numbers)) {
        result = sum(n, 2)
        io.print(result)
    }
}

So my question is, is there any technical reason behind this syntax, or is it just a personal preference of the team? Especially that the team behind Go used "C Language" to write Go, which means it would've made much more sense to type it in C-Style syntax ?

Few points that I'd like to highlight:

1. Go is inspired by many languages and not just C.

• C: statement and expression syntax
• Pascal: declaration syntax
• Modula 2, Oberon 2: packages
• CSP, Occam, Newsqueak, Limbo, Alef: concurrency
• BCPL: the semicolon rule
• Smalltalk: methods
• Newsqueak: <-, :=
• APL: iota
• There are more

2. From when foreach and range become C-style syntax?
3. Third, don't confuse "For" statements with for clause and range clause. Read the spec.
   In Go, you can do this is as well:

for i := 0; i < len(numbers); i++

But range clause is much more powerful once you understand it and yes it is not strange syntax. I'd suggest to read the spec and see a few examples.

4. Also, it's Go and not GoLang (Read). Always prefer the former over the latter.
5. Try the Go Tour. Some concepts are explained well.

Also, read Go's FAQ and Pike's blog on declaration syntax. The FAQ should answer many such queries.

import "io"

Go has fmt and io packages, although they do have some overlap. For example, fmt.Fprint lets you write to any io.Writer, and fmt.Fscan lets you read from any io.Reader.

Similarly you can write to console with io.Copy(os.Stdout, something), and read from console with io.Copy(something, os.Stdin).

int sum(int a, int b) {

I think I read that by having func first, it makes lexical parsing much faster. Also Go function can have named return values:

func sum(a int, b int) (n int)

I am not sure how you'd do that with the other syntax.

int numbers[4] = {1, 2, 3, 4}

Go syntax allows you to omit the type, which you can't do with C.

foreach (n in range(numbers))

Go doesn't have a while keyword, for the reason that less keywords again makes for faster lexical parsing. Instead you have different for invocations:

var n int
for {
   if n > 9 {
      break
   }
   println(n)
   n++
}

var n int
for n < 9 {
   println(n)
   n++
}

for n := 0; n < 9; n++ {
   println(n)
}

for range numbers {
   println("hello")
}

for index := range numbers {
   println(index)
}

for index, value := range numbers {
   println(index, value)
}

For this:

result = sum(n, 2)

Go has two different syntax for variable assignment:

result := 1
result = 2

First is a declaration, second is assigning to an already declared variable.

io.print(result)

fmt.Println is uppercase, because any function that starts with an uppercase letter is a "public" function. This saves on typing public or pub everywhere.