4

I have learned (from a SML book) that functions in SML always takes just one argument: a tuple. A function that takes multiple arguments is just a function that takes one tuple as argument, implemented with a tuple binding in function binding. I understand this point.

But after this, the book says something that I don't understand:

this point makes SML language flexible and elegant design, and you can do something useful that you cannot do in Java.

Why does this design make the language Flexible? What is the text referring to, that SML can but java cannot?

Jesper.Reenberg
  • 5,944
  • 23
  • 31
hqt
  • 29,632
  • 51
  • 171
  • 250

2 Answers2

6

Using tuples instead of multiple arguments adds flexibility in the sense that higher-order functions can work with functions of any "arity". For example to create the list [f x, f y, f z], you can use the higher-order function map like this:

map f [x, y, z]

That's easy enough - you can do that in any language. But now let's consider the case where f actually needs two arguments. If f were a true binary function (supposing SML had such functions), we'd need a different version of map that can work with binary functions instead of unary functions (and if we'd want to use a 3-ary functions, we'd need a version for those as well). However using tuples we can just write it like this:

map f [(x,a), (y,b), (z,c)]

This will create the list [f (x,a), f (y,b), f (z,c)].

PS: It's not really true that all functions that need multiple arguments take tuples in SML. Often functions use currying, not tuples, to represent multiple arguments, but I suppose your book hasn't gotten to currying yet. Curried functions can't be used in the same way as described above, so they're not as general in that sense.

sepp2k
  • 363,768
  • 54
  • 674
  • 675
3

Actually I don't think you really understand this at all.

First of all, functions in SML doesn't take a tuple as argument, they can take anything as argument. It is just sometimes convenient to use tuples as a means of passing multiple arguments. For example a function may take a record as argument, an integer, a string or it may even take another function as argument. One could also say that it can take "no arguments" in the sense that it may take unit as the argument.

If I understand your statement correctly about functions that takes "multiple arguments" you are talking about currying. For example 

fun add x y = x + y

In SML, currying is implemented as a derived form (syntactic sugar). See this answer for an elaboration on how this actually works. In summary there is only anonymous functions in SML, however we can bind them to names such that they may "referred to"/used later.

Behold, ramblings about to start.

Before talking about flexibility of anything, I think it would be in order to state how I think of it. I quite like this definition of flexibility of programming languages: "[...] the unexpectedly many ways in which utterings in the language can be used"

In the case of SML, a small and simple core language has been chosen. This makes implementing compilers and interpreters easy. The flexibility comes in the form that many features of the SML language has been implemented using these core language features such as anonymous functions, pattern matching and the fact that SML has higher-order functions.
Examples of this is currying, case expressions, record selectors, if-the-else expressions, expression sequences.

I would say that this makes the SML core language very flexible and frankly quite elegant.

I'm not quite sure where the author was going regarding what SML can do, that java can't (in this context). However I'm quite sure that the author might be a bit biased, as you can do anything in java as well. However it might take immensely amounts of coding :)

Community
  • 1
  • 1
Jesper.Reenberg
  • 5,944
  • 23
  • 31
  • 2
    When the OP says "A function that takes multiple arguments is just a function that takes one tuple as argument", I'm pretty sure he's talking about `fun add (x,y) = x+y`, which looks (to people coming from other languages) like a function taking two arguments, but really only takes a tuple. I don't think he's aware of currying at all. – sepp2k Jan 28 '13 at 01:51
  • @sepp2k, you are possibly correct. I might have jumped to conclusions. However the original question was barely understandable nor readable. – Jesper.Reenberg Jan 28 '13 at 15:09
  • In SML all functions are single argument functions. Yes, in SML a function can take an integer, a string or any other function too. But they are in fact tuples. for example, you may say that the function `fun add_by_one (x) = x + 1` takes an integer but I will argue saying even though the function has a type `int -> int`, you have overlooked the fact that the type of a tuple with a single integer (eg. `(1)`) is also `int`. If there is a function that takes two ints and returns an int then the type of the function is `int * int -> int` where `int * int` is a tuple. – dhaliman Mar 06 '18 at 01:25
  • All SML functions are single argument functions and they all take tuples as an argument. Also, note that tuples are syntactic sugar for a record with fields in the order 1, 2, 3... – dhaliman Mar 06 '18 at 01:29