A feature of certain functional programming languages such as ML. In languages such as C, pascal, Java etc. if you have a function of several arguments then you have to supply all of the arguments at once. In ML however i can do the following

fun map (f:'a->'b) (x::l) = (f x) :: (map f l)
|map _ [] =[];

This function takes a list of elements of type 'a and a function that takes an argument of type 'a and returns a value of type 'b, as arguments and returns the list obtained by applying f to all the elements of the list. The

ML type of this function is fn : ('a -> 'b) -> 'a list -> 'b list.

An equivalent function could easily be written in C, using function pointers, although the list would have to be of type void * in order to mimic the polymorphism we have in ML.

But what you can do in ML that you can't do in traditional languages is something like this :

val Mymap = map f;

where f is a function already defined.

**We have applied the function map partially to f**. Mymap is a new function that takes a list as a

parameter and applies f to all the elements of the list. Mymap is not just an

alias or a

macro for map f : if you change map or f, Mymap will not be changed. You can even do something like

val mymap2= map (map f)

which is a function that takes a list of lists of items type 'a and returns a list of lists of items obtained by applying f.

A more down to earth example is as follows:

fun derivative f (delta:real) x = ((f (x+delta))-(f (x-delta)))/(2.0*delta);

As you can see, this function calculates the

derivative of f at the

point x by calculating the

slope between x-delta and x+delta. Still nothing I can't do in

C. But in

ML I can do this :

val derivativeOfF = derivative f .001;

like before derivativeOfF is a

**new** function that is an approximation of the derivative of f

In the end, it's a pretty cool feature that like many of the elements of languages like ML helps you to write concise and elegant code.