Trouble with Curry functions (SML/NJ)

Question

Often we are interested in computing f(i) i=m n∑ , the sum of function values f(i) for i = m through n. Define ‘sigma f m n’ which computes f(i) i=m n∑ . This is different from defining ‘sigma (f, m, n)’

I'm required to write a Curried version of this function. I'm have a bit of trouble understanding how this would actually work. I understand that a Curry function is something that takes in a function and produces a function. Would this be an example of a curry function?

fun myCurry f x = f(x)

As far as setting up my problem, would this be an acceptable start?

fun sigma f m n =

I haven't gotten any further, because I can't really grasp what i'm being asked to do.

Answer 1

A curried function is not, in fact, a function that takes in a function and produces another function. That is a higher order function.

A curried function is simply one that takes more than one argument and can be partially applied by only giving it one of its arguments.

For example, with your sigma question,

fun sigma (f,m,n) = ...

is not a curried function, as it takes only one argument (the tuple (f,m,n).)

fun sigma f m n = ...

, however, is a curried function, as it takes three arguments, and it is valid to say something like

val sigmasquare = sigma (fn x => x * x)

, partially applying sigma by giving it its first argument.

A simpler example would be

fun add (x,y) = x + y

This is a noncurried function. To evaluate it, you must give it its argument, which includes both x and y. add (3,5) will evaluate to 8, in this case.

fun add x y = x + y

is the curried version of this same function. This can be partially evaluated by just giving it x. For example, add 3 will evaluate to a function which will add three to its argument.

This is more clearly seen by looking at the previous examples as anonymous or lambda functions.

The first is equivalent to fn (x,y) => x + y, which clearly takes two ints and evaluates to an int.

The second is equivalent to fn x => fn y => x + y, which takes an int and evaluates to a function taking another int and evaluating to an int.

Thus, the type of the first is (int * int) -> int, while the type of the second is int -> int -> int.

Hopefully, this clears currying up somewhat.