Hacker News Reader

Hacker News

Comment by crudbug | Hacker News Reader

Full thread

crudbug

Can we have a consistent function notation

fn name(a: int, b: int) -> void {}

This also helps with clean functional type arguments.

swift and rust support this.

A single consistent notation will be helpful for new polyglots.

View on HN

IMHO, "fn add(a: int, b: int): int" is far more consistent than "fn add(a: int, b: int) -> int". At least it is self consistent.

Thats precisely the reason its written like that in Mun

Having -> denote a return variable has the benefit that you the syntax "a -> b" is non-ambiguously a function type.

For example, a function that accepts a function as an argument can be written:

    fn foo(f: int -> string)

Or if the argument name isn't needed in this context (e.g. think interface declarations):

  fn foo(int -> string)

If you see ":" as meaning "has type", then using it for a return type isn't necessarily more consistent, because it's not the function that has a type.

Some reasonable, but I see a new inconsistency here. Shouldn't

    fn foo(fn (int) -> string)

be more consistent?

It's not inconsistent, just terser. You could say that "fn" declares a function by name; the type of foo is int -> str.

In Haskell, this is written:

  foo :: int -> str

Of course, Haskell is based on lambda calculus, so multiple arguments are just a generalization of partial function application:

  foo :: int -> int -> str

(A function taking two int arguments and returning a string, which is indistinguishable from a function that takes a single int and returns a function that takes a single int and returns a string.)

Ah, looks both have their own rationality. ":" is ok for single-value returns. AS3 also uses ":".

The Haskell language looks interesting. Maybe I should spend some time to study it.

In functional programming (the origin of this syntax),

  add(a: int, b: int): int

can be read as a function 'add' when applied to the parameter tuple (a: int, b: int) has type int, I believe Ocaml, SML, actually support this syntax, whereas '->' (arrow) is a function type constructor in functional programming with 'A -> B' denoting a function from A to B. The type of add by itself in a language like Haskell would be:

add :: (int, int) -> int

Not quite, in ML languages, a function declared like this:

  let sum a b = a + b

...has the type:

  float -> float -> float

Same in Haskell.

These languages "emulate" multiple arguments through partial function application. OCaml does not use tuples for arguments.

You can certaintly have tupled function arguments in SML/Ocaml, in fact that seems to have been the more common style there, whereas Haskell uses curried functions more commonly.

As far as the original sugestion, using '->' (arrow) to denote a return type (like Rust) is nonsense in a functional language and kind of butchering the functional inherited syntax IMHO.

I've never heard of OCaml tuples being more common in arguments. If anything, my impression is they're discouraged (in OCaml, not SML) as a replacement for curried arguments. E.g. see [1].

> is nonsense in a functional language

SML/OCaml and Haskell all use ->, so I'm not sure what you mean by this?

[1] https://stackoverflow.com/questions/10666913/why-prefer-curr...

It is quite common in SML/ML code I've encountered, probably not as common in modern OCaml. BTW, in OCaml

  let add ((a:int), (b:int)) : int = a + b

Works just fine, whereas:

  let add ((a:int), (b:int)) -> int = a + b

is nonsense, because '->' is a type constructer in OCaml (a function from types to types) not part of an ad-hoc syntax for function declarations (like Rust).

Right, I'm not sure with OCaml is inconsistent there. -> is also used in pattern matching and in the syntax "fun x -> x + 1", perhaps it's some historical thing to avoid ambiguity?

The above usage of -> is a syntax error in OCaml, -> can be used in the left hand side of a let expression, but only as part of a type expression. As you say the other usage is used to construct terms (clauses) that are used in pattern matching, of course Haskell does something similar.

The Rust syntax seems to emulate functional programming, but inconsistently since -> is not used purely as a type constructor or term constructor something like a mix of both in the defintion of functions, also it doesn't seem to support currying.

Can we have a consistent function notation

void name(int a, int b) {}

C, C++, Java, and C# support this.

A single consistent notation will be helpful for new polyglots.

Or func add(x int, y int): int { return x + y }

This way it would be consistent with how variable types are declared.

I was honestly just trying to show how ridiculous of a request GP is making.

What's the purpose of the stylized ASCII arrow "->" / why is it needed?

Looks like it denotes return type? Are you implying it can be omitted syntactically because the closing paren implies the return type would follow?

You mean like in Go?

    func add(x int, y int) int {
        return x + y
    }

I doubt this is more readable, but everyone has their own taste.

Depends on the language but in Haskell, the (->) arrow is a function type constructor (i.e. constructs function at type level) where a -> b constructs a function type from a to b.

This is often chained to produce functions that 'take multiple arguments'. i.e. a -> b -> b. I put that in quotations because in reality all functions take only one argument, this is called currying. It gives functions flexibility in that you can partially apply them at will.

In languages like Rust and Swift, the syntax is (a: A, b: B) -> B. Because these languages are "uncurried", they use the syntax of uncurried functions. Meaning, they cannot be readily partially applied.

The thing about adopting the ASCII Art pseudo arrow is that it bakes in an assumption that the dash character lines up vertically with the point on the angle bracket character. This simply isn't the case in plenty of fonts. So it often looks like crap if you pay attention.

Which fonts does it not look good in? Haskell, Rust, Swift, Ocaml, and I'm sure some others, all use this notation. And I've never seen the '->' look odd in any font I've ever used.

I just went to the Rust homepage and clicked until I found an example of a function. It's being presented in Monaco where the dash is noticeably higher than the centre of the angle bracket.

I haven't used anything other than linux for more than a decade so that probably explains it. Still, I've never heard this complaint before.

> And I've never seen the '->' look odd in any font I've ever used.

Funny; I'm reading this in a HN android app; I don't know which font it uses but I swear I'm staring at such a misaligned example.

Intuitively, `a -> b` is normally interpreted as "from `a`, I can get `b`".

A function of type `Int -> String` allows you to get a `String` from an `Int`.

The proposition `A -> B` (`A` implies `B`) means that `A` being true allows `B` to be true; we can deduce `B` from `A`.

For the link between functions and implication, see: https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspon...

I don't think it makes sense to say `fn read(s: string) -> int` as in Rust though. If an arrow were used in such a function declaration, it should probably look something more like:

  fn read: (s: string) -> int

As another commenter has indicated, `fn read(s: string): int` states that `read(s)` is of type `int`, which is logical.

Reply on news.ycombinator.com