The worst decision regarding Rust syntax was following C++ syntax. Due to this, we write, in type syntax

Things<Like<This, That>, That> -- as in C++

Instead of a more legible (and very familiar to Rust authors)

Things (Like This That) That -- as in Haskell

Inherited from C++, we had also :: for namespacing (while a dot . could be perfectly be used for that), and tons of other stuff like <> for scoping generics.

Without some of that we could have:

    pub fn read<P: AsRef Path>(path: P) -> io.Result (Vec u8) {
      fn inner(path: &Path) -> io.Result (Vec u8) {
        let mut file = File.open(path)?;
        let mut bytes = Vec.new();
        file.read_to_end(&mut bytes)?;
        Ok(bytes)
      }
      inner(path.as_ref())
    }

Perhaps it looks a little better? It looks for me, at least.

For doing better than that we could drop C-like syntax perhaps?

The trouble is that languages have a weirdness budget - there's a finite amount of novel stuff a language can have until it becomes too weird for mainstream programmers. So language designers have to pick their weird features carefully. Spending it all in novel syntax is unwise.

I think that at the time the Rust pull was safety for low level code and, as Rust was targeted to replace some C++ components, following C++ syntax was seen as a good idea.