What's the origin of -> in Rust function definition return types?

Question

Rust uses colons to separate identifiers from types, like in

let x: u8 = 1;

However, for function return types -> is used instead. Example:

fn f() -> u8 { ... }

One might expect it to use a colon here as well:

fn f(): u8 { ... }

While using arrows has some precedence (e.g. in Haskell), I'm curious about the historical reason behind this choice. In addition, I'm also curious if it's a purely aesthetic reason or if using an arrow has some technical reason e.g. in simplifying parsing.

Answer 1

Well, I’m only guessing, but I’d say that the reason is purely aesthetic. : is often pronounced as “has the type”, while -> is pronounced as “to”. So f: fn(i32) -> i32 means “f has the type of functions from i32 to i32”.

Basically, there are two contexts where the return value of a function can be mentioned:

1. Function item declaration:

   fn foo(x: i32) -> i32 {
     …
   }
   

2. Assignment of a function to a variable with explicit type:

   let f: fn(x: i32) -> i32 = foo;
   

While using colon instead of arrow wouldn’t hurt readability in the first case, it would definitely do so in the second one. And it makes perfect sense to have the same symbol in both contexts.

The ultimate origin of this arrow is Simply Typed Lambda Calculus where this arrow is used as the function type constructor. From there it came to Haskell, Scala (well, not exactly, they use =>) and other languages.