Hacker News new | ask | show | jobs
by chewxy 3924 days ago
Because you write functions like this in mathematics as well.

What we usually see is something like this:

    f(x) = y
But if you look at it carefully the function f is a mapping of the domain x to the range y (the arrow is f), written like so:

    x -> y
Of course, the domain, being a set of all permissible values, is the type. So we write the type instead:

    type1 -> type2
Everything in Haskell is a function, and pure functions only ever take ONE parameter. Therefore the commas make no sense. The name in front just aids in naming stuff.

If you have a function that takes 2 parameters, they'd have to be curried. How would you represent curried functions?

    f::type1 -> type2 -> type3
To make it more concrete, let's look at add instead of f.

So we can define a function like this (let's use Python for its readability):

    def add(a, b): return a + b
But remember, in haskell, functions are pure. Meaning they only map one input to one output. In order to make this happen, we need to split the function up into parts that only take one parameter.

Let's start with the plus operator as a function (it is one in Haskell just made into an infix). To think about it, it'd be something like this:

    plus(a)(b)
Where plus(a) is defined as:

    def plus(a): return plusA
Hence the first part would become a curried function like so, which takes another parameter:

    plusA(b)
Where plusA() is defined as such:

    def plusA(b): return b + a # a is a constant
So if you look at it from the types it was being transformed from:

    plus() # takes a Real, returns plusA.

    plusA(___) # takes a Real, returns a Real. written as (Real -> Real)
So if you put it together, the function signature for plus() is:

plus() takes Real -

    plus :: Real->
plus() returns plusA (which is Real->Real) -

    plus :: Real-> (Real-> Real)
Or in other words we can write it as such

    add :: Real -> Real -> Real
1 comments
zaptheimpaler 3924 days ago
I don't understand one thing about this notation:

   fun :: A -> B -> C -> D
can be bracketed in a bunch of different ways -

   fun1 :: (A -> B) -> (C -> D)
   fun2 :: A -> (B -> C -> D)
etc. and don't these all mean different things?

fun1 would take a function and return a function, whereas fun2 takes an A and returns a curried function of B,C -> D.

link
Muphrid 3923 days ago
The order of operations here is "right associative". So

  A -> B -> C -> D
is equivalent to any of the following

  A -> (B -> C -> D)
  A -> (B -> (C -> D))
  A -> B -> (C -> D)
They're equivalent through currying. But you can only add or remove parentheses for stuff that is on the right of a function arrow. (A -> B) -> (C -> D) is a different thing.
link
dwenzek 3924 days ago
Read:

   fun :: A -> (B -> (C ->D))
link
kryptiskt 3923 days ago
Yes, functions need to be bracketed, as they are single arguments with a complex type.
link