Why make it complicated?

Can't say I've ever experienced this kind of confusion in Java but that's probably because they intentionally restricted the syntax so there's no ambiguity.

Also useful when the types are optional, like Python. Though they don’t use any let or var or anything so maybe throw that entire point out the window

But does it really make less sense to say “a string slice”?

That’s an interesting point. You say “a pizza slice” or “a slice of pizza”, but you only say “a slice of bread”, not “a bread slice” (right? I’m not a native speaker).

Go's syntax is vastly superior once you have more complicated signatures, then the left-to-right truly matters. For example a variable that contains a pointer to a function that takes a function and an int and returns another function (like a decorator).

In C the order becomes very hard to understand and you really have to read the thing several times to understand the type of fp:

int (*(*fp)(int (*)(int, int), int))(int, int)

In Go, you can just read from left to right and you can easily understand what f's type is:

f func(func(int,int) int, int) func(int, int) int

It's just much more readable.

See: https://go.dev/blog/declaration-syntax

Both of those declarations look weird to me. In Haskell it would be:

 undefined

    
a :: Stringbob :: (String, Int, Double) -> [String]bob (a, b, c) = ...

  

... except that makes bob a function taking a tuple and it's much more idiomatic to curry it instead:

 undefined

    
bob :: String -> Int -> Double -> [String]bob a b c = ...-- syntactic sugar for:-- bob = \a -> \b -> \c -> ...

  

The [T] syntax also has a prefix form [] T, so [String] could also be written [] String.

OCaml makes the opposite choice. In OCaml, a list of strings would be written string list, and a set of lists of strings would be string list set, a list of lists of integers int list list, etc.

True enlightenment is realizing that variables don't exist, it's all just a sequence of bits in RAM that we assign meaning to as desired.

Ascension is realizing that bits don't exist, it's all just trapped electrons in transistors which we imagine to be bits.

Transcendence is realizing that transistors or code doesn't exist, and it's just some quarks and electrons attracted and repulsed by weird forces, vibrating and convulsing in a soup with entropy constantly rising until the heat death of the universe, of which we make futile attempts to make sense or purpose.

Are you the person who’s writing these APIs that just return dynamically generated untyped JSON that I need to deal with on my team at work? Typing absolutely matters and I will die on this hill

Isn't that how B worked?

void* isOdd(void* ptr);

Look at what you made me do.

char**

You can also do that in TypeScript

 undefined

    
readonly a!: Foo;
readonly b = bar.toFoo();

constructor(){
    a = bar.toFoo();
}

  

What about

 undefined

    
Let ret: Number
If (someCondition) {
    <a lot of expensive calculations>
    ret = resultOfOperations
} else {
    <a lot of other different expensive operations>
    ret = resultOfOtherOperations
}
return ret

  

You can't declare ret inside the brackets

What about you declare (then it gets allocated in stack) it and pass it to a different context for assignment?

You left a “can rot in hell” between your php and forever

It's like saying 'inline styles only forever' when comparing to modern CSS