Chapter 7:
The functional paradigm: From an arithmetic core to ML

There is a paradigm of programming that dispenses with traditional assignment. As a result, computation in this paradigm, the functional paradigm, looks somewhat like algebra, where one does equals-for-equals substitution to compute the answer that is bound (once and forever) to a name.

The reason one might take seriously this approach is because many many errors arise due to updating a cell in the wrong order or due to updating a shared cell or due to a race condition. The problem has appeared recently in multi-core processors, where there are huge problems with synchronizing all the processors' caches with primary storage.

Examples of functional programming languages are Lisp, Scheme, ML, Ocaml, and Haskell. We study their principles in this chapter.

The rewriting machine: A new computational model

   +-----+
   | CPU | (controller)
   +-----+
      |
      V
+---------------+-+-+- ... +-+-+
| program codes | | |      | | |
+---------------+-+-+- ... +-+-+
                (data table saved in cells)

But not all computations are table driven. Think about arithmetic! Here is a "program" --- (3 * (4 + 5) --- and its computation:

(3 * (4 + 5)) =  (3 * 9) =  27

The rewriting rules for arithmetic can be stated in algebra-equation style, using a formalism called a Post system. If we represent (nonnegative) numbers in Base 1 format (e.g., 0 is 0, 1 is s0, 2 is ss0, 3 is sss0, etc.), then only four equations are needed to define addition and multiplication:

(0 + N) =  N
(sM + N) =  (M + sN)

(0 * N) =  0
(sM * N) =  (N + (M * N))

As an exercise, compute (2 * 3), that is (ss0 * sss0):

(ss0 * sss0) =  (sss0 + (s0 * sss0))  
             =  (sss0 + (sss0 + (0 * sss0)))
             =  (sss0 + (sss0 + 0))
             =  (sss0 + (ss0 + s0)) 
             =  (sss0 + (s0 + ss0)) =  (sss0 + (0 + sss0)) =  (sss0 + sss0)
             =  . . .  =  ssssss0

+----------------------------------+
| hard-wired equations for * and + | (in real life, an ALU holds this wiring)
+----------------------------------+
      |
      V
+------------------------+
| arithmetic expression  |
+------------------------+

Based on the arithmetic example, you can readily imagine a ``universal rewriting machine,'' which operates with user-defined equations and an expression:

  +-------------------------+
  | equation-rewrite engine |
  +-------------------------+
      |            |
      V            V
+------------+-----------------+
| equations  | expression tree |
+------------+-----------------+

There is an even more exotic version of rewriting, called the lambda calculus, where there is only one operator, λ, and programs and data are coded just with it and algebra variables. Here are some codings:

0:   (λs(λz z))
1:   (λs(λz (s z)))
2:   (λs(λz (s (s z))))
     and so on

M + N :  ((M plusOne) N) 
      where   plusOne :   (λn(λs(λz (s ((n s) z)))))

M * N :  ((M +) N)

((λx M) N) =  [N/x]M
   where  [N/x]M  is the replacement of all (free) occurrences of  x  by  N  in M

Now we are ready to learn the functional programming paradigm, which does computing as program rewriting. As shown above, the rewriting can be implemented as a machine that traverses and constructs operator trees.

7.1 Arithmetic and algebra

===================================================

E: Expression
N: Numeral

E ::=  N  |  E1 + E2  |  E1 - E2  |  E1 * E2 
N ::=  sequences of digits

===================================================

(2 * (4 - 3)) + 5 =  (2 * 1) + 5 =  2 + 5 =  7

When you learned algebra, you learned that expressions can be named. The language of algebra is arithmetic extended with expression abstracts:

===================================================

P: AlgebraProgram
D: Definition
E: Expression

P ::=  given D solve E
D ::=  I = E  |  D1 and D2
E ::=  N  |  E1 + E2 | E1 * E2 | I

===================================================

((A + B) + C) = (A + (B + C))            (i)
(A + B) = (B + A)                        (ii)
(A + 0) = A                              (iii)

((A * B) * C) = (A * (B * C))            (iv)
(A * B) = (B * A)                        (v)
(A * 1) = A                              (vii)

(A * (B + C)) = ((A * B) + (A * C))      (viii)

given
   y = 2 * x
and
   z = y + 1
solve 
   2 * z

2 * z = 2 * (y + 1)                    # substitute for z
      = (2 * y) + (2 * 1)              # (viii)
      = (2 * y) + 2                    # 2 * 1 = 2
      = (2 * (2 * x)) + 2              # substitute for y
      = ((2 * 2) * x) + 2              # (iv)
      = (4 * x) + 2                    # 2 * 2 = 4

7.2 A core language for list structures

Here is a core language that resembles core Lisp or core ML; the expressibles are atoms and lists. For the moment, there are no denotables and no storables:

===================================================

E: Expression
A: Atom (words)

E ::=  A  |  nil  | E1 :: E2  |  hd E  |  tl E |  ifnil E1 then E2 else E3
A ::= strings of letters

===================================================

• An atom is a string, like "abc".
• nil is a list with nothing in it. In Python and ML, nil is written []. (We will follow a classic Lisp convention and treat nil and "nil" as the same value(!) If this sounds wierd to you, don't worry about it....)
• E1 :: E2 places the value denoted by E1 on the front of the list denoted by E2:

  "a" :: nil is a list of one element. (We can write this as ["a"] in ML.)

  "b" :: ("a" :: nil) evaluates to a two-element list, where "b" is first and "a" second. (We can write this as ["b", "a"] in ML. (:: is a kind of ``stack push.'')

  In Lisp, :: is written cons, e.g., (cons "b" (cons "a" nil)). For this reason, we read :: as "cons".
• hd E (read as "head E") returns the front element of list, E, e.g., hd ("b" :: ("a" :: nil)) computes to "b". (It is like ``stack top.'')
• tl E (read as "tail E") returns a new list missing the former front element, e.g., tl ("b" :: ("a" :: nil)) is "a" :: nil. (It is like ``stack pop.'')
• ifnil E1 then E2 else E3 chooses to compute E2 or E3 depending on whether E1 computes to an empty list.

  (In ML, you would say, if E1 = nil then E2 else E3, and in general, if B then E2 else E3, where B is a boolean-typed expression.)

===================================================


hd (E1 :: E2)  =  E1                        (i)

tl (E1 :: E2)  =  E2                        (ii)

ifnil nil then E1 else E2  =  E1            (iii)

ifnil (E1 :: E2) then E3 else E4  =  E4     (iv)

===================================================

We have an ``arithmetic'' for lists, based on these equations. Here's one small example, a list that mixes atoms and lists:

"a" :: (tl (hd (("b" :: nil) :: ("c" :: nil))))

= "a" :: (tl ("b" :: nil))      # rule (i)

= "a" :: nil                    # rule (ii)

Here's another example:

ifnil ("a" :: nil)
  then  nil
  else  hd (tl ("b" :: ("c" :: nil)))

= hd (tl ("b" :: ("c" :: nil)))         # rule (iv)

= hd ("c" :: nil) =  "c"                # rules (ii) and (i)

ifnil ("a" :: nil)
  then  nil
  else  hd (tl ("b" :: ("c" :: nil)))

= ifnil ("a" :: nil)
    then  nil
    else hd ("c" :: nil) 

= ifnil ("a" :: nil)
    then  nil
    else "c"

= "c"

So far, our language doesn't look like much, but since we can build lists that mix atoms and other lists, we can easily model trees, tables, dictionaries, and indeed all the important data structures of computer science. And with one key extension (parameterized expression abstracts that can call themselves), we will achieve a language that has the same computing power as all known programming languages.

This next example shows we can embed a conditional expression inside an expression:

"a" :: (ifnil nil then nil else ("b" :: nil))   =   "a" :: nil 

Finally, we can use :: to glue a list to an atom or an atom to an atom, e.g., "a" :: "b" and nil :: "a". These data structures are called dotted pairs, and they are like Python pairs.

7.2.1 Control structures

The interactive version of ML uses a weak sequential control: After an expression is computed to its answer, the answer is saved in a temporary variable, named it. The expression that evaluates next can reference it, and once that expression finishes, its answer becomes the new value of it. Here is an example of a sequence of three expressions to simpify, separated by semicolons:

"a" :: nil;  hd it;  it :: (it :: nil)

7.3 Expression abstracts

===================================================

D: Definition
E: Expression
A: Atom
I: Identifier

E ::=  A  |  nil  |  E1 :: E2  |  hd E  |  tl E 
    |  ifnil E1 then E2 else E3  |  let D in E end  |  I

D ::=  val I = E 

===================================================

We add one new rewriting equation to our semantics:

===================================================

let val I = E1 in E2 end  =  [ E1 / I ] E2

===================================================

Here is an example:

let val x = "a" :: nil  in
    let val y = "b" :: x  in
        x :: (tl y) end
end

===================================================

let val x = "a" :: nil  in
    let val y = "b" :: x  in
    x :: (tl y) end  end

= let val y = "b" :: ("a" :: nil) in
    ("a" :: nil) :: (tl y) end  

= ("a" :: nil) :: (tl ("b" :: ("a" :: nil)))

= ("a" :: nil) :: ("a" :: nil)

===================================================

As usual, the example can be worked in another order:

===================================================

let val x = "a" :: nil  in
    let val y = "b" :: x  in
    x :: (tl y) end  end

= let val x = "a" :: nil  in
      x :: (tl ("b" :: x) end

= let val x = "a" :: nil  in
      x :: x              end

= ("a" :: nil) :: ("a" :: nil)

===================================================

let definitions can be embedded, like this:

tl (let x = nil in x :: (let y = "a" in y :: x end) end)

===================================================

= tl (let x = nil in x :: ("a" :: x) end)

= tl (nil :: ("a" :: nil))

= "a" :: nil

===================================================

Here is a more delicate example, where we redefine x in nested blocks. (This is similar to writing a procedure that contains a local variable of the same name as a global variable.)

===================================================

let val x = "a"  in
    let val y = x :: nil  in
        let val x = nil  in
           y :: x
        end
    end
end

===================================================

let val x = "a"  in
   let val x = nil  in
      (x :: nil) :: x
   end
end

The example displays a famous problem that dogged 19th-century logicians. The solution is, when we substitute for an identifier, we never allow a clash of two definitions --- we must rename the inner definition, if necessary. In the earlier example, if we substitute for y first, then we must eliminate the clash between the two defined xs by renaming the inner x:

===================================================

let val x = "a"  in
    let val y = x :: nil  in
        let val x' = nil  in
           y :: x'
        end
    end
end

===================================================

We can define substitutation and renaming precisely with equations. The equations cover all possible cases of substitution and only the last 3 equations are interesting:

===================================================

let val I = E1 in E2 end  =  [ E1 / I ] E2

where

[ E0 / I ] A  =  A           # atoms are left alone

[ E0 / I ] nil  =  nil       # so is nil


[ E0 / I ] E1 :: E2  =  [ E0 / I ]E1 :: [ E0 / I ]E2    # substitute into both parts

[ E0 / I ] hd E  =  hd [ E0 / I ]E    # substitute into the subexpression...

[ E0 / I ] tl E  =  tl [ E0 / I ]E

[ E0 / I ] ifnil E1 then E2 else E3  =
    ifnil  [ E0 / I ]E1  then  [ E0 / I ]E2  else  [ E0 / I ]E3

[ E0 / I ] let D in E end  =  let  [ E0 / I ]D  in  [ E0 / I ]E  end


[ E0 / I ] I  =  E0     # replace  I

[ E0 / I ] I' =  I'     if  I' not= I   # don't alter a var different than I


[ E0 / I ] val I' = E   =   val I' = [ E0 / I ]E   if  I not= I' and  I' does not appear in  E0
       # that is, if there is no name clash


[ E0 / I ] val I = E   =   val I = E    # do nothing because  I is redefined here


[ E0 / I ] val I' = E   =   val I'' = [ E0 / I ][ I'' / I' ]E  
       if  I not= I' and  I' appears in E0  and  I''  is a new name that does not appear in either  E0  or  E
            # if there is a name clash, rename  I'  to some new  I''

===================================================

A machine based on equation rewriting can apply the above substitution laws without problem. Still, the equations are defining an expression-tree traversal algorithm that it is easy to implement.

7.4 Interpreter architecture for functional languages

Exercise

===================================================

ifnil nil then E1 else E2  =  E1

ifnil (E1 :: E2) then E3 else E4  =  E4

hd (E1 :: E2)  =  E1

tl (E1 :: E2)  =  E2

let val I = E1 in E2 end =  [ E1 / I ] E2

===================================================

let val x = "a" :: nil 
in  ifnil x  then nil
             else (hd x) :: x
end

There is another approach --- Recall from Chapter 1 that function interpret traversed an expression tree and computed its meaning by computing and combining the meanings of its subtrees. In picture form, interpret computed like this:

Our interpreter reads the programmer as an operator tree and uses heap storage. When the interpreter computes the meaning of a subtree, it constructs the meaning in the heap from two-celled objects, called cons cells. Each let subtree constructs a namespace. Once an object is constructed in heap storage, it is never altered. This allows massive, natural, sharing of data structures and eliminates sequencing, sharing, and race errors.

Here is how the earlier program computes:

Here is the syntax of operator trees; it closely matches the source syntax:

===================================================

ETREE ::=  ATOM  |  ["nil"]  |  ["cons", ETREE, ETREE] |  ["head", ETREE] 
        |  ["tail", ETREE]  |  ["ifnil", ETREE1, ETREE2, ETREE3]
        |  ["let", DTREE, ETREE]  |  ["ref", ID]

DLIST ::=  [  [ID, ETREE]+ ]
        that is, a list of one or more  [ID, ETREE]  pairs

ATOM  ::=  a string of letters
ID    ::=  a string of letters, not including keywords

===================================================

let val x = "abc" :: nil 
    val y = ifnil x then nil else hd x
in
    y :: x 
end

["let", [["x", ["cons", "abc", ["nil"]]],
         ["y", ["ifnil", ["ref", "x"],
                         ["nil"],
                         ["head", ["ref", "x"]] ]]],
        ["cons", ["ref", "x"], ["ref", "y"]]] 

Here is the code for the interpreter:

===================================================

"""Interpreter for functional language with  cons  and  simple let.

Here is the syntax of operator trees interpreted:

ETREE ::=  ATOM  |  ["nil"]  |  ["cons", ETREE, ETREE] |  ["head", ETREE] 
        |  ["tail", ETREE]  |  ["ifnil", ETREE1, ETREE2, ETREE3]
        |  ["let", DLIST, ETREE]  |  ["ref", ID]

DLIST ::=  [  [ID, ETREE]+ ]
        that is, a list of one or more  [ID, ETREE]  pairs

ATOM  ::=  a string of letters
ID    ::=  a string of letters, not including keywords

"""

### HEAP:

heap = {}
heap_count = 0  # how many objects stored in the heap

"""The program's heap --- a dictionary that maps handles
                          to namespace or cons-pair objects.

      heap : { (HANDLE : NAMESPACE or CONSPAIR)+ }
        where 
         HANDLE = a string of digits
         NAMESPACE = {IDENTIFIER : DENOTABLE} + {"parentns" : HANDLE or "nil"} 
            that is, each namespace must have a "parentns" field
         CONSPAIR = (DENOTABLE, DENOTABLE)
         DENOTABLE = HANDLE or ATOM or "nil"
         ATOM = string of letters

   Example:
     heap = { "0": {"w": "nil", "x": "ab", "parentns": "nil"},
              "1": {"z":"2", "parentns":"0"},
              "2": ("ab","nil"), 
              "3": {"y": "4",  "parentns":"1"},
              "4": ("2","2")
            }
     heap_count = 5
        is an example heap, where handles "0","1","3"  name  namespaces
        which hold definitions for  w,x,z,y,  due to  let  expressions.
        Handles "2" and "4" name cons-cells that are constructed due to
        a use of  cons.
        This example heap might have been constructed by this expression:
         let val w = nil 
             val x = "ab" in
         let z = x :: w in
         let y = z :: z in
          ...

       The values computed are  w = [],  x = "ab",  z = ["ab"], y = [["ab"], "ab"]
"""

### ASSOCIATED MAINTENANCE FUNCTIONS FOR THE  heap:

def isHandle(v) :
    """checks if  v  is a legal handle into the heap"""
    return isinstance(v, str) and v.isdigit() and  int(v) < heap_count


def allocate(value) :
    """places  value  into the heap with a new handle
       param:  value - a namespace or a pair
       returns the handle of the newly saved value
    """
    global heap_count
    newloc = str(heap_count)
    heap[newloc] =  value
    heap_count = heap_count + 1
    return newloc


def deref(handle):
    """ looks up a value stored in the heap: returns  heap[handle]"""
    return heap[handle]


### MAINTENANCE FUNCTIONS FOR NAMESPACES:


def lookupNS(handle, name) :
    """looks up the value of  name  in the namespace named by  handle
       If  name  isn't found, looks in the  parentns and keeps looking....
       params: a handle and an identifier 
       returns: the first value labelled by  name  in the chain of namespaces 
    """
    if isHandle(handle):
        ns = deref(handle)
        if not isinstance(ns, dict):
            crash("handle does not name a namespace")
        else :
            if name in ns :
                ans = ns[name]
            else :   # name not in the most local ns, so look in parent:
                ans = lookupNS(ns["parentns"], name)   
    else :
        crash("invalid handle: " + name + " not found")
    return ans


def storeNS(handle, name, value) :
    """stores  name:value  into the namespace saved at  heap[handle]
    """
    if isHandle(handle):
        ns = deref(handle)
        if not isinstance(ns, dict):
            crash("handle does not name a namespace")
        else :
            if name in ns :
                crash("cannot redefine a bound name in the current scope")
            else : 
                ns[name] = value


#########################################################################

# See the end of program for the driver function,  interpretPTREE


def evalETREE(etree, ns) :
    """evalETREE computes the meaning of an expression operator tree.

      ETREE ::=  ATOM  |  ["nil"]  |  ["cons", ETREE, ETREE] |  ["head", ETREE] 
        |  ["tail", ETREE]  |  ["ifnil", ETREE1, ETREE2, ETREE3]
        |  ["let", DLIST, ETREE]  |  ["ref", ID]

       post: updates the heap as needed and returns the  etree's value,
    """

    def getConspair(h):
        """dereferences handle  h  and returns the conspair object stored
           in the heap at  h
        """
        if isHandle(h):
            ob = deref(h)
            if isinstance(ob, tuple):  # a pair object ?
                ans = ob
            else :
                crash("value is not a cons pair")
        else :
            crash("value is not a handle")
        return ans


    ans = "error"
    if isinstance(etree, str) :  #  ATOM
        ans = etree 
    else :
        op = etree[0]
        if op == "nil" :
            ans = op

        elif op == "cons" :
            arg1 = evalETREE(etree[1], ns)
            arg2 = evalETREE(etree[2], ns)
            ans = allocate((arg1,arg2))   # store new conspair in heap

        elif op == "head" :
            arg = evalETREE(etree[1], ns)
            ans, tail = getConspair(arg)
 
        elif op == "tail" :
            arg = evalETREE(etree[1], ns)
            head, ans = getConspair(arg)

        elif op == "ifnil" :
            arg1 = evalETREE(etree[1], ns)
            if arg1 == "nil" :
                ans = evalETREE(etree[2], ns)
            else :
                ans = evalETREE(etree[3], ns)

        elif op == "let" :
            newns = evalDLIST(etree[1], ns)  # make new ns of new definitions
            ans = evalETREE(etree[2], newns)  # use new ns to eval ETREE
            # at this point,  newns  isn't used any more, so forget it!

        elif op == "ref" :
            ans = lookupNS(ns, etree[1])

        else :  crash("invalid expression form")
    return ans


def evalDLIST(dtree, ns) :
    """computes the meaning of a sequence of new definitions and stores
       the  ID, meaning  bindings in a new namespace
           DTREE ::=  [ [ID, ETREE]+ ]
       returns a handle to the new namespace
    """
    newns = allocate({"parentns": ns})  # create the new ns in the heap
    for bindingpair in dtree :  # add all the new bindings to the new ns
        name = bindingpair[0]
        expr = bindingpair[1]
        value = evalETREE(expr, newns)
        storeNS(newns, name, value)
    return newns


###########################

def crash(message) :
    """pre: message is a string
       post: message is printed and interpreter stopped
    """
    print message + "! crash! ns=", ns, "heap=", heap
    raise Exception   # stops the interpreter


def prettyprint(value):
    if isHandle(value):
        v = deref(value)
        if isinstance(v, tuple):
           ans = "(cons " + prettyprint(v[0]) + " " + prettyprint(v[1]) +")"
        else :
           ans = "HANDLE TO DICTIONARY AT " + v
    else :
        ans = value
    return ans
        

# MAIN FUNCTION ###########################################################

def evalPGM(tree) :
    """interprets a complete program 
       pre: tree is an ETREE
       post: final values are deposited in heap
    """
    global heap, heap_count
    # initialize heap and ns:
    heap = {}
    heap_count = 0

    ans = evalETREE(tree, "nil")
    print "final answer =", ans
    print "pretty printed answer =", prettyprint(ans)
    print "final heap ="
    print  heap

    raw_input("Press Enter key to terminate")


===================================================

evalPGM( ["cons", "abc", ["nil"]] )

evalPGM( ["head", ["cons", "abc", ["nil"]]] )

evalPGM( ["ifnil", ["nil"], ["head", ["cons", "abc", ["nil"]]], "def"] )

evalPGM( ["let", [["x", "abc"]], ["cons", ["ref", "x"], ["nil"]]] )

evalPGM( ["let", [["x", ["cons", "abc", ["nil"]]]],
                 ["cons", ["ref", "x"], ["ref", "x"]]])

evalPGM( ["let", [["x", ["cons", "abc", ["nil"]]], ["y", "nil"]],
                 ["cons", ["ref", "x"], ["ref", "y"]]] )

One important point: there is no activation stack in the interpreter. Instead, each interpretTREE function is parameterized on the handle of the namespace it should use for doing variable lookups. This technique accomplishes the same work of an activation stack without all the coding overhead --- the stack is ``threaded'' through the sequence of function calls.

7.5 Expression parameters

Definitions can be parameterized; the result are functions:

===================================================

E ::=  ... |  [ E* ]  |  let D in E end  |  I  |  I(E*)
D ::=  val I = E  |  fun I1(I2*) = E  |  D1 D2

===================================================

When a function is defined, its code (expression) is saved. When the function is called, its arguments bind to its parameters, and the function's code evaluates. Here is a small example:

===================================================

let fun second(list) = let val rest = tl list
                       in  hd rest
in
second(tl("a" :: ("b" :: ( "c" :: nil))))

===================================================

The argument binds to the parameter name when the function is called. The rewriting might go like this: (We have a better way to do it in a moment!)

===================================================

second(tl("a" :: ("b" :: ( "c" :: nil))))

= let val list = tl("a" :: ("b" :: ( "c" :: nil))) in   # bind the arg to the param
  let val rest = tl list in
  hd rest

= let val rest = tl( tl("a" :: ("b" :: ( "c" :: nil)))) in
  hd rest

= hd ( tl( tl("a" :: ("b" :: ( "c" :: nil)))))

= ... = "c"

===================================================

7.5.1 Lambda abstractions

The previous example did not implement the function call in precisely the style we have used so far. In particular, we should substitute the code for second into the position where second is referenced. Let's see where this leads us.

The definition,

fun second(list) = let val rest = tl list
                   in  hd rest  end

val second = (list) let val rest = tl list  
                    in  hd rest end

===================================================

val second = lambda list : let val rest = tl list
                           in  hd rest end

===================================================

(Important: in ML, the lambda abstraction is coded, fn list => let val rest = tl list in hd rest end.)

The lambda expression comes with this semantic equation, which is a variant of the one we use for let:

===================================================

(lambda I : E1) E2  =  [ E2 / I ] E1

===================================================

Let's rework the previous example using the lambda abstraction:

let val second = lambda list: let val rest = tl list in hd rest end
    in  second(tl("a" :: ("b" :: ( "c" :: nil))))
end

= (lambda list: let val rest = tl list in hd rest end)(tl("a" :: ("b" :: ( "c" :: nil)))

= let val rest = tl (tl("a" :: ("b" :: ( "c" :: nil)))) in hd rest

= hd( tl (tl("a" :: ("b" :: ( "c" :: nil)))) )

= ... = "c"

Here is the ``minimal form'' of our functional language:

===================================================

E ::=  ...  |  let D in E end  |  I  |  E1(E2*)  |  lambda I*: E
D ::=  val I = E  |  D1 D2

===================================================

"a" :: (lambda x: (x :: x))(nil) 

=  "a" :: (nil :: nil)

Now the language's characteristic domains go as follows: the expressible values are atoms, lists, and functions on expressibles. The denotable values are exactly the expressibles. There are still no storable (updateable) values.

7.5.2 Adding closures to the interpreter

As before, a closure object is a pair, consisting of function-code-plus-parent-namespace-pointer. A couple of pictures will make this clear. For this sample program:

===================================================

 . . .
let val second = lambda list: hd (tl list)  
in  let val x = "a" :: ("b" :: nil)
    in  second(x) :: x  
end end

===================================================

7.6 Recursively defined functions

A function can restart itself by looking up its own definition; this is called recursion. (You can see this in the previous picture: the code for second can refer to itself if it wishes.) A recursive call executes exactly the same way as any other function call; no new machinery is needed.

Recursion with parameters can substitute for assignment and iteration. This example,

x = 0
while x < 100 :
    print x
    x = x + 1
end

let fun printloop(x) = if x < 100
                       then (print(Int.toString(x)); print("\n");
                             printloop(x+1))
                       else nil   (* done -- do nothing *)
in printloop(0)
end

Here is a useful ML function that reads a sequence of text lines from the keyboard and collects the lines into a list. The function reads one line and restarts itself to read more lines. It quits when it sees a "!":

===================================================

fun collectText() =
    let val txt = TextIO.inputLine TextIO.stdIn   
             in  if hd (explode txt) = #"!"     (* if head is "!" *)
                 then []                        (* then quit *)
                 else txt :: collectText()      (* else save and RESTART *)
    end

===================================================

===================================================

(* collectText reads a sequence of text lines from the input terminal
   and assembles them into a list of strings.  It quits when it sees
   a "!" as the first character of a textline.  
   It returns the list of strings as its answer.
*)
fun collectText() =
    let val t = TextIO.inputLine TextIO.stdIn   (* read the line *)
    in  if isSome(t)                            (* if line is nonempty *)
        then let val txt = valOf(t)             (* then pull out its text *)
             in  if hd (explode txt) = #"!"     (* if head char is "!" *)
                 then []                        (* then quit *)
                 else txt :: collectText()      (* else save txt and RESTART *)
             end
        else []
    end;

===================================================

hello there.

123
!

The ML instructions for textual input are ugly, so here is the recursion pattern again, this time to build a list of the first k+1 powers of 2. For example, powers(3) computes and returns the list, [8,4,2,1]: The example shows how recursive calls assemble a data structure in stages, from ``back to front'':

===================================================

(* powers builds of list of powers of two from  2**k down to 2**0
   param:  k  the upper bound, a nonnegative int
   returns: a list, [2**k, 2**(k-1) ..downto.. 2**0]
*)
fun powers(k) =
    if k = 0
    then [1]                                 (* because 2**0 = 1 *)
    else let val answers = powers(k - 1) in 
         (* assert:  answers  holds [2**(k-1) ..downto.. 2**0]  *)
         (2 * (hd answers)) :: answers       (* cons  2**k  to  answers *)
         end
;

===================================================

===================================================

powers(3)

= let val answers = powers(2) in
  in (2 * (hd answers)) :: answers 
  end

= let val answers = (let val answers = powers(1) 
                     in (2 * (hd answers)) :: answers
                     end)
  in (2 * (hd answers)) :: answers 
  end    


= let val answers = (let val answers = (let val answers = powers(0)
                                        in (2 * (hd answers)) :: answers
                                        end)
                     in (2 * (hd answers)) :: answers
                     end)
  in (2 * (hd answers)) :: answers
  end

===================================================

===================================================

= let val answers = (let val answers = (let val answers = [1]
                                        in (2 * (hd answers)) :: answers
                                        end)
                     in (2 * (hd answers)) :: answers
                     end)
  in (2 * (hd answers)) :: answers
  end

= let val answers = (let val answers = (2 * (hd [1])) :: [1]
                     in (2 * (hd answers)) :: answers
                     end)
  in (2 * (hd answers)) :: answers
  end

= let val answers = (let val answers = [2,1]
                     in (2 * (hd answers)) :: answers
                     end)
  in (2 * (hd answers)) :: answers
  end

= ...

= let val answers = [4,2,1]
    in (2 * (hd answers)) :: answers
  end

= [8,4,2,1]

===================================================

Perhaps we want the numbers in ascending order. We reverse a list in ML like this, again using recursion to build the answer in stages:

===================================================

(* reverse reverses the elements in a list.
   param: ns - a list, e.g, ["c","b","a"]
   returns: a list that holds the items of ns in reverse order, e.g., ["a","b","c"]
*)
fun reverse(ns) =
    if ns = []
    then  []
    else  reverse(tl ns) @ [hd ns]    (* in ML,  @  means list append *)

===================================================

The recursion was done with the tail of the argument list, that is, with a list that is one smaller than the original argument. In this way, we ``count down'' (disassemble) the list down to an empty one, which stops the recursions.

In ML, we can define functions on lists in an equational style, with parameter patterns, like this:

===================================================

(* reverse reverses the elements in a list.
   param: ns - a list, e.g, ["c","b","a"]
   returns: a list that holds the items of ns in reverse order, e.g., ["a","b","c"]
*)
fun reverse(nil) = []
|   reverse(n :: ns) = reverse(ns) @ [n]

===================================================

Finally, people who like loops often write this variant of list reverse. The second parameter is called an accumulator, because it accumulates the answer in stages:

===================================================

(* reverseloop(ns, ans)  reverses the items in list  ns  and appends them
    to the end of  ans.
   params:  both  ns  and  ans  are lists.
   returns: a list that holds the elements of  ans  followed by
    the elements of  ns  in reverse order.
   To use the function to reverse a list,  x,  do this:  reverseloop(x, []).
*)
fun reverseloop(nil, ans) = ans
|   reverseloop(n::ns, ans) = reverseloop(ns, n :: ans)

===================================================

Using parameter patterns, we can easily write a function that searches a list for a value:

===================================================

(* member(v, xs)  searches list  xs  to see if  v  is a member in it.
   params:  v - a value;  xs - a list of values
   returns: true exactly when  v  is found in  xs
*)
fun member(v, nil) = false
|   member(v, (w::rest)) = if v = w  then true
                           else member(v, rest)

===================================================

7.6.1 Application: Maintaining a table and undoing its updates

1. An update to a table actually constructs a new cons cell that holds the update and a link to the old table.
2. If there is an error or a security breach, a sequence of updates are easily rolled back (undone) by reverting to the handle of the table as it looked before the updates were appended to it.

Here is a small example, where a user can issue update, lookup, and undo commands to a database that holds key,value pairs. Notice that the database is actually a handle to a list, assembled from cons cells, in the heap. An update adds a new cons cell to the database, and an undo resets the database's handle:

===================================================

(* A database of (key,value) pairs, modelled as a list of form,
    (k1,v1) :: ((k2,v2) :: ... :: nil))
*)

(* Auxiliary function update adds a new key,value pair to the database.
   The new pair cancels any existing pair with the same key.
   params:  key, value
   returns: the (handle to) the updated database
*)
fun update(key, value, database) = 
    let val newdatabase = (key, value) :: database
    in  newdatabase 
    end

(* Auxiliary function lookup finds the value corresponding to a key in  the database.
   params:  key, database
   returns: the value such that  (key,value)  lives in the database
*)
fun lookup(k, database) =
    if database = []
    then raise Empty   (* error --- empty database *)
    else let val (key,value) = hd database 
         in  if key = k    (* is desired value the most recent update? *)
             then value
             else lookup(k, tl database)    (* if not, look deeper... *)
         end


(* Main function  processTransaction is a "loop" that reads user requests and
   processes the database accordingly.   The requests are either:
      -- update key value
      -- lookup key
      -- undo most previous update
   Params:  database: (the handle to) the current database
            history: a list of handles to previous databases
*)
fun processTransaction(database, history) =
    (* 3 lines of ugly ML code to read one textline:  *)
    let val text = TextIO.inputLine TextIO.stdIn 
    in  if isSome(text)
        then let val request = valOf(text) in
             (* now, we decode and process the request:  *)
             ...extract command, key, value, etc. from  request...
             if command = "update"
             then let val newDatabase = update(key, value, database)
                  in  (print("update transaction\n");
                      processTransaction(newDatabase,  database :: history)
                      )
                  end
             else if command = "lookup"
                  then (print("lookup transaction\n");
                       print (lookup(key, database));
                       processTransaction(database, history)
                       )
             else if command = "undo"
                  then (print("undo transaction\n");
                       processTransaction(hd history, tl history)
                       )
             else raise Empty  (* bad command *)
             end
        else print "End of Session";
             ... code here to archive the database on disk ...
    end

===================================================

Of course, Amazon or Google do not use simple list implementations of their databases. Instead, spelling trees ("tries") or hash tables are extended with cons-cell-style update. We look at trees and other structures in the next section.

7.6.2 Inductively defined datatypes

Other languages, like ML and Haskell, use a Pascal/Java-like type system, where each value has a specific type; all the elements of a list must have the same type; and only values of the same type can be compared for equality.

Let's look at ML, which uses a type checker. Here is the syntax of types in ``core ML'':

===================================================

T: Type

T ::=  string  |  T list

===================================================

"a"  has type  string

"a" :: nil,  which evaluates to  ["a"],   has type  string list

nil :: (("a" :: nil) :: ("a" :: ("b" :: nil))),
  which evaluates to  [[], ["a"], ["a","b"]],  has type  (string list) list

===================================================


A : string             E1 : T    E2 : T list
                     ------------------------
                         E1 :: E2 : T list

E : T list             E : T list
-----------          ---------------
hd E : T             tl T : T list


E1 : T list   E2 : T'   E3 : T'
---------------------------------
 if E1 = nil E1 then E2 else E3 : T'

===================================================

- nil :: (("a" :: nil) :: ("a" :: ("b" :: nil)));

val it = [[], ["a"], ["a","b"]] : (string list) list

One question remains: What is the type of nil? The answer is, T' list, for any type T' whatsoever. So, nil has ``many types,'' depending on where it is inserted in an expression. (See the earlier examples.) For this reason, its ``typing rule'' goes:

===================================================

nil : T List

===================================================

When you define an ML function, the type checker checks the function's code and calculates the type. The interpreter constructs the function's closure and shows the type, e.g.,

- fun double(n) = n * 2;

val double = fn : int -> int

Sometimes an function can be used with arguments of different types, e.g.,

- fun second(xs) = hd(tl xs);

val second = fn : 'a list -> 'a

If we have types, we can can have ``type abstracts,'' where we give names to types. This idea was used brilliantly by Rod Burstall in the language, Hope and adapted by Luca Cardelli into the modern version of ML, now called SML ("Standard ML"). Here is a type abstract that defines a data type of binary trees that hold ints at their nodes:

===================================================

datatype IntTree = Leaf |  Node of int * IntTree * IntTree

===================================================

===================================================

Leaf   which represents a leaf tree,   *

Node(2, Node(1, Leaf, Leaf), Node(5, Leaf, Leaf))  which represents   2
                                                                     / \
                                                                    1   5
                                                                   * * * *
let val t = Node(1, Leaf, Leaf) in
let val u = Node(5, t, t) in
in  Node(3, t, u)
end end                         which represents       3
                                                     /   \
                                                    1     5
                                                   * *   / \
                                                        1   1
                                                       * * * *
   or, for that matter, represents     3
                                     /   \ 
                               +--> 1     5
                               |   * *   / \
                               |________|__|

   because the implementation shares substructure.

===================================================

We can use parameter patterns defined by a datatype. Say that we use IntTree to build ordered binary trees. Here is a tree-search algorithm expressed with patterns:

===================================================

(* member(i, t)  searches ordered IntTree t for int i *)
fun member(i, Leaf) = false
|   member(i, Node(j, t1, t2)) = if i = j then true
                                 else if i < j  then member(i, left)
                                      else member(i, right)
;

val member = fn : int * IntTree -> IntTree

===================================================

===================================================

(* collect(t)  returns a list holding all the ints in  IntTree  t  *)
fun collect(Leaf) = []
|   collect(Node(i, left, right)) = collect(left) @ [i] @ collect(right)
;

val collect = fn : IntTree -> int list

===================================================

===================================================

(* insert(i, t)  inserts  i  into ordered tree  t
   pre: i  is an int;   t  is an IntTree whose nodes are ordered
   post: returns an ordered IntTree containing t's values and  i
*)
fun insert(i, Leaf) = Node(i, Leaf, Leaf)
|   insert(i, Node(j, left, right)) =
             if i < j then Node(j, insert(i, left), right)
                      else Node(j, left, insert(i, right))
;

val insert = fn : int * IntTree -> IntTree

===================================================

User-defined datatypes define schemas for data-structure building, much like classes do for object-oriented programming. Here are some types for a library's database, modelled as a list of entries of books and DVDs:

datatype Item =  Book of string * string   (* Book(title,author) *)
              |  Dvd of string             (* Dvd(title)         *)

datatype DBEntry = Entry of int * Item     (* Key(idnumber, item) *)

type Database = DBEntry list

Datatypes work great for defining tree-like structures that mix strings, ints, subtrees, lists, etc. If you review Chapter 1 on grammars, interpreters, and parsers, you see inductively-defined data types everywhere. For example, for this syntax of expressions:

EXPR ::=  DIGIT  |  - EXPR  |  ( EXPR + EXPR )

===================================================

datatype ETree = Digit of char  |  Negation of Etree  |  Addition of Etree * Etree

===================================================

===================================================

(* interpretETree computes the int meaning of its ETree argument  *)
fun interpretETree(Digit c)  =  (ord(c) - ord(#"0"))
|   interpretETree(Negation(t))  =   -(interpretETree(t))
|   interpretETree(Addition(t1,t2))  =  interpretETree(t1) + interpretETree(t2)
;

val interpretETree = fn : ETree -> int

===================================================

7.6.3 Map, filter, reduce

It is easy to use parameter patterns to write exactly these structures for an inductively defined data type. Here are three sample instances of these control structures for binary trees of values:

===================================================

datatype 'a Tree = Leaf  |  Node of 'a * Tree * Tree

fun map(f, Leaf) =  Leaf
  | map(f, Node(a, t1, t2)) = Node(f(a), map(f, t1), map(f, t2))

fun filter(b, Leaf) = []
  | filter(b, Node(a, t1, t2)) = (if b(a) then [a] else [])
                                 @ filter(f, t1) @ filter(f, t2)

fun reduce(r, startvalue, Leaf) = startvalue
  | reduce(r, startvalue, Node(a, t1, t2)) =
              let v1 = reduce(r, startvalue, t1) in
              let v2 = reduce(r, v1, t2) in
              r(a, v2)
              end end

===================================================

ML has built-in versions of map and reduce (two variants: foldl and foldr) for linear lists.

7.7 Conclusion

The computation-as-algebra concept fails with imperative languages, because identifiers denote variables whose stored values change from line to line. For example, if we have an imperative program, like this one,

int x;
int y;
x = 0;
if ... {
    x = x + 1 }
else {
    x = 2
}
y = x;

In summary, imperative languages work with storage structures that are incrementally updated, for example, a voting table or a graphics system that maintains the pixels on a display.

In contrast, functional languages solve self-contained problems that assemble inputs into a data structure and then process the data structure into an answer. An example is a compiler, which translates an input program into a tree data structure and then processes the tree into output code. Or, a batch payroll system that converts a file of payroll information into a file of paycheks. Or, a library of numerical functions that compute answers to questions in physics or biology.

When you face a problem that can be solved by equational-style calculation, solve it with a functional language.