Rust's Ugly Syntax(matklad.github.io)

    let (a, mut b) = //some tuple

    pub fn read(path: impl AsRef<Path>) -> io::Result<Vec<u8>> {

    public func read(path: URL) throws -> Array<UInt8> {
        let file = try FileHandle(forReadingFrom: path)
        let bytes = try file.readToEnd() ?? Data()
        return Array(bytes)
    }

  use std;
  use std`fs`File;
  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())
  }

    X!(T)
    X!T

   let foo: Result<T, Error> = try {
       x()?;
       y()?;
       Ok(z)
   };

    fn foo(x: impl Into<String>, y: impl Into<String>) {
        ...
    }

    fn foo<T: Into<String>, U: Into<String>(x: T, y: U) {
        ...
    }

  > At the mention of ugly source code, people will of course think of
  > Perl. But the superficial ugliness of Perl is not the sort I mean. Real
  > ugliness is not harsh-looking syntax, but having to build programs out
  > of the wrong concepts. Perl may look like a cartoon character swearing,
  > but there are cases where it surpasses Python conceptually.

  let mut file;
  match File::open(path) {
      Ok(value) => { file = value; }
      Err(error) => { return Err(error); }
  }

    inner path = do