5

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.

user2796815
  • 465
  • 2
  • 11
  • 18

1 Answers1

12

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.

Matt Bryant
  • 4,841
  • 4
  • 31
  • 46
qaphla
  • 4,707
  • 3
  • 20
  • 31
  • I'm still unclear on how I would apply it to my problem. I have to create multiple functions? – user2796815 Sep 24 '13 at 19:33
  • Yes, pattern matching in curried functions can be done in exactly the same way as in noncurried functions. (Also, note that they are called curried functions, not curry functions). – qaphla Sep 24 '13 at 19:37
  • @qaphla How do I specify the types explicitly for your example `fun add x y`. For example, I want `x` and `y` to be real, and in the function I round them before summing, and the `add` function returns an int. – Old Geezer Oct 04 '15 at 15:13
  • Hi you can do that by specifying the result of the function to be real Eg: add x y : real = x + y; – Ram G Athreya May 04 '17 at 02:47