1.1k
views6
comments

0 score	+
	-

Type Question

Hi Guys,

Just trying to wrap my head around this great language. Looking at the following (and comments)

// the following has a type int -> int -> int


let add = (+)


// the following has a type int -> int


let addAndHalfParams = (+) 1

I get the type of the second let statement. However, the 1st one - what does that mean? Why the two ASCII arrows?

Cheers

.Reply

Two arrows means two parameters. In the second case you're passing in a first parameter, which creates a function waiting for it's second and final parameter. In the first case you're still waiting for both parameters.

Arrow can be seen as 'returns a value'. So 'int -> int -> int' should be read as a function that takes and int and returns a function that takes an int and returns an int.

The effect is more formally know as currying, so you may want to read up on that.

Hope that makes sense!

Robert

By Robert on 4/26/2010 2:29 AM (permalink)Reply

The function type is written without parentheses because you can interpret it as

(int->int)->int

i.e. a function of 2 ints returning an int, or

int->(int->int),

i.e. a funtion of an int, that returns a partial function from an int to an int (as in (+) 1 ).

By mau on 4/27/2010 4:16 AM (permalink)Reply

@mau,

actually the arrow in function types definitions is right associative so int -> int -> int precisely translates to your second interpretation i.e. int->(int->int). The first one, (int->int)->int specifies an entirely different type, that is a function taking a function from int to int and returning an int (for instance let g f = 1 + f 1).

edit : sorry for the redundant answer (one should obviously always check for a brian's posting just before pressing the 'post' button [:)])

By bubobubo on 4/27/2010 4:54 AM (permalink)Reply

The function type is written without parentheses because you can interpret it as (int->int)->int i.e. a function of 2 ints returning an int, or int->(int->int), i.e. a funtion of an int, that returns a partial function from an int to an int (as in (+) 1 ).

Conceptually this gives you an idea, but being pedantic, the parentheses matter, and

(int->int)->int

is a different entity, specifically a one argument function that takes an int-to-int function as an argument and returns an integer as a result. This is different from a

int->int->int ( == int->(int->int) )

which takes an int and returns an int-to-int function.

Topic tags

Built with WebSharper

Home

Answers

Events

Courses

Groups and Conferences

Blogs

Jobs

Developers

Topic tags