2012-01-27
- Implementing First Class Function Values
- The FLANG Language
- Introducing Racket's `lambda'
- Using Functions as Objects
- Currying

========================================================================
>>> Implementing First Class Function Values

[[[ PLAI Chapter 6 (uses some stuff from ch. 5, which we do later) ]]]

This is a simple plan, but it is directly related to how functions are
used in our language -- there are three basic approaches that classify
programming languages:

1. First order: functions are not real values.  They cannot be used or
   returned as values by other functions.  This means that they cannot
   be stored in data values.  This is what you are/will be implementing
   in homework 4, and most `conventional' languages used to have in the
   past.

   An example of such a language is the Beginner Student language that
   is used in HtDP, where the language is intentionally first-order to
   help students write correct code (at the early stages where using a
   function as a value is usually an error).  It's hard to find
   practical modern languages that fall in this category.

2. Higher order: functions can receive and return other functions as
   values.  This is what you get with C.

3. First class: functions are values with all the rights of other
   values.  In particular, they can be supplied to other functions,
   returned from functions, stored in data structures, and new functions
   can be created at run-time.  (And most modern languages have first
   class functions.)

The last category is the most interesting one.  Back in the old days,
complex expressions were not first-class in that they could not be
freely composed.  This is still the case in machine-code: as we've seen
earlier, to compute an expression such as

  (-b + sqrt(b^2 - 4*a*c)) / 2a

you have to do something like this:

  x = b * b
  y = 4 * a
  y = y * c
  x = x - y
  x = sqrt(x)
  y = -b
  x = y + x
  y = 2 * a
  s = x / y

In other words, every intermediate value needs to have its own name.
But with proper ("high-level") programming languages (at least most of
them...) you can just write the original expression, with no names for
these values.

With first-class functions something similar happens -- it is possible
to have complex expressions that consume and return functions, and they
do not need to be named.

What we get with our `fun' expression (if we can make it work) is
exactly this: it generates a function, and you can choose to either bind
it to a name, or not.

This has a major effect on the "personality" of a programming language
as we will see.  In fact, just adding this feature will make our
language much more advanced than some popular languages you know so far.

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

Quick Example: the following is working JavaScript code, that uses first
class functions.

  function foo(x) {
    function bar(y) { return x + y; }
    return bar;
  }
  function main() {
    var f = foo(1);
    var g = foo(10);
    alert(">> "+ f(2) + ", " + g(2));
  }

Note that the above definition of `foo' does *not* use an anonymous
"lambda expression" -- in Racket terms, it's translated to

  (define (foo x)
    (define (bar y) (+ x y))
    bar)

The returned function is not anonymous, but it's not really named
either: the `bar' name is bound only inside the body of `foo', and
outside of it that name is irrelevant.

GCC includes extensions that allow internal function definitions, but it
still does not have first class functions -- trying to do the above is
broken:

  #include <stdio.h>
  typedef int(*int2int)(int);
  int2int foo(int x) {
    int bar(int y) { return x + y; }
    return bar;
  }
  int main() {
    int2int f = foo(1);
    int2int g = foo(10);
    printf(">> %d, %d\n", f(2), g(2));
  }

========================================================================
>>> The FLANG Language

Now for the implementation -- we call this new language FLANG.

First, the BNF:

  <FLANG> ::= <num>
            | { + <FLANG> <FLANG> }
            | { - <FLANG> <FLANG> }
            | { * <FLANG> <FLANG> }
            | { / <FLANG> <FLANG> }
            | { with { <id> <FLANG> } <FLANG> }
            | <id>
            | { fun { <id> } <FLANG> }
            | { call <FLANG> <FLANG> }

And the matching type definition:

  (define-type FLANG
    [Num  Number]
    [Add  FLANG FLANG]
    [Sub  FLANG FLANG]
    [Mul  FLANG FLANG]
    [Div  FLANG FLANG]
    [Id   Symbol]
    [With Symbol FLANG FLANG]
    [Fun  Symbol FLANG]
    [Call FLANG FLANG])

The parser for this grammar is, as usual, straightforward:

  (: parse-sexpr : Sexpr -> FLANG)
  ;; to convert s-expressions into FLANGs
  (define (parse-sexpr sexpr)
    (match sexpr
      [(number: n)    (Num n)]
      [(symbol: name) (Id name)]
      [(cons 'with more)
       (match sexpr
         [(list 'with (list (symbol: name) named) body)
          (With name (parse-sexpr named) (parse-sexpr body))]
         [else (error 'parse-sexpr "bad `with' syntax in ~s" sexpr)])]
      [(cons 'fun more)
       (match sexpr
         [(list 'fun (list (symbol: name)) body)
          (Fun name (parse-sexpr body))]
         [else (error 'parse-sexpr "bad `fun' syntax in ~s" sexpr)])]
      [(list '+ lhs rhs) (Add (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '- lhs rhs) (Sub (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '* lhs rhs) (Mul (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '/ lhs rhs) (Div (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list 'call fun arg) (Call (parse-sexpr fun) (parse-sexpr arg))]
      [else (error 'parse-sexpr "bad syntax in ~s" sexpr)]))

We also need to patch up the substitution function to deal with these
things.  The scoping rule for the new function form is, unsurprisingly,
similar to the rule of `with', except that there is no extra expression
now, and the scoping rule for `call' is the same as for the arithmetic
operators:

    N[v/x]                = N

    {+ E1 E2}[v/x]        = {+ E1[v/x] E2[v/x]}

    {- E1 E2}[v/x]        = {- E1[v/x] E2[v/x]}

    {* E1 E2}[v/x]        = {* E1[v/x] E2[v/x]}

    {/ E1 E2}[v/x]        = {/ E1[v/x] E2[v/x]}

    y[v/x]                = y
    x[v/x]                = v

    {with {y E1} E2}[v/x] = {with {y E1[v/x]} E2[v/x]}
    {with {x E1} E2}[v/x] = {with {x E1[v/x]} E2}

    {call E1 E2}[v/x]     = {call E1[v/x] E2[v/x]}

    {fun {y} E}[v/x]      = {fun {y} E[v/x]}
    {fun {x} E}[v/x]      = {fun {x} E}

And the matching code:

  (: subst : FLANG Symbol FLANG -> FLANG)
  ;; substitutes the second argument with the third argument in the
  ;; first argument, as per the rules of substitution; the resulting
  ;; expression contains no free instances of the second argument
  (define (subst expr from to)
    (cases expr
      [(Num n) expr]
      [(Add l r) (Add (subst l from to) (subst r from to))]
      [(Sub l r) (Sub (subst l from to) (subst r from to))]
      [(Mul l r) (Mul (subst l from to) (subst r from to))]
      [(Div l r) (Div (subst l from to) (subst r from to))]
      [(Id name) (if (eq? name from) to expr)]
      [(With bound-id named-expr bound-body)
       (With bound-id
             (subst named-expr from to)
             (if (eq? bound-id from)
               bound-body
               (subst bound-body from to)))]
      [(Call l r) (Call (subst l from to) (subst r from to))]
      [(Fun bound-id bound-body)
       (if (eq? bound-id from)
         expr
         (Fun bound-id (subst bound-body from to)))]))

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

Now, before we start working on an evaluator, we need to decide on what
exactly do we use to represent values of this language.  Before we had
functions, we had only numbers and we used (Racket) numbers to represent
them.  Now we have two kinds of values -- numbers and functions.  It
seems easy enough to continue using Racket numbers to represent numbers,
but what about functions?  What should be the result of evaluating

  {fun {x} {+ x 1}}

?  Well, this *is* the new toy we have: it is a function *value*, which
is something that can be used just like numbers, but instead of
arithmetic operations, we can `call' these things.

To accommodate this, we will change our implementation strategy a
little: we will use our syntax objects for numbers (`(Num n)' instead of
just `n'), which will be a little inconvenient when we do the arithmetic
operations, but it will simplify life by making it possible to evaluate
functions in a similar way: simply return their own syntax object as
their values.  This means that evaluating:

  (Add (Num 1) (Num 2))

now yields

  (Num 3)

and a number `(Num 5)' evaluates to `(Num 5)'.

In a similar way, `(Fun 'x (Num 2))' evaluates to `(Fun 'x (Num 2))'.

Why would this work?  Well, because `call' will be very similar to
`with' -- the only difference is that its arguments are ordered a little
differently, being retrieved from the function that is applied and the
argument.

The formal evaluation rules are therefore treating functions like
numbers, and use the syntax object to represent both values:

  eval(N)         = N

  eval({+ E1 E2}) = eval(E1) + eval(E2)

  eval({- E1 E2}) = eval(E1) - eval(E2)

  eval({* E1 E2}) = eval(E1) * eval(E2)

  eval({/ E1 E2}) = eval(E1) / eval(E2)

  eval(id)        = error!

  eval({with {x E1} E2}) = eval(E2[eval(E1)/x])

  eval(FUN)       = FUN ; assuming FUN is a function expression

  eval({call E1 E2})
                  = eval(Ef[eval(E2)/x])   if eval(E1) = {fun {x} Ef}
                  = error!                 otherwise

Note that the last rule could be written using a translation to a `with'
expression:

  eval({call E1 E2})
                  = eval({with {x E2} Ef}) if eval(E1) = {fun {x} Ef}
                  = error!                 otherwise

And alternatively, we could specify `with' using `call' and `fun':

  eval({with {x E1} E2}) = eval({call {fun {x} E2} E1})

There is a small problem in these rules: we now have two kinds of
values, so we need to check the arithmetic operation's arguments too:

  eval({+ E1 E2}) = eval(E1) + eval(E2)
                      if eval(E1) & eval(E2) are numbers
                      otherwise error!
  ...

The corresponding code is:

  (: eval : FLANG -> FLANG)                      ; <- note return type
  ;; evaluates FLANG expressions by reducing them to *expressions*
  (define (eval expr)
    (cases expr
      [(Num n) expr]                             ; <- change here
      [(Add l r) (arith-op + (eval l) (eval r))]
      [(Sub l r) (arith-op - (eval l) (eval r))]
      [(Mul l r) (arith-op * (eval l) (eval r))]
      [(Div l r) (arith-op / (eval l) (eval r))]
      [(With bound-id named-expr bound-body)
       (eval (subst bound-body
                    bound-id
                    (eval named-expr)))]         ; <- no `(Num ...)'
      [(Id name) (error 'eval "free identifier: ~s" name)]
      [(Fun bound-id bound-body) expr]           ; <- similar to `Num'
      [(Call (Fun bound-id bound-body) arg-expr) ; <- nested pattern
       (eval (subst bound-body                   ; <- just like `with'
                    bound-id
                    (eval arg-expr)))]
      [(Call something arg-expr)
       (error 'eval "`call' expects a function, got: ~s" something)]))

Where the `arith-op' function is in charge of checking that the input
values are numbers (represented as FLANG numbers), translating them to
plain numbers, performing the Racket operation, then re-wrapping the
result in a `Num'.  Note how its type indicates that it is a
higher-order function.

  (: arith-op : (Number Number -> Number) FLANG FLANG -> FLANG)
  ;; gets a Racket numeric binary operator, and uses it within a FLANG
  ;; `Num' wrapper (note H.O type)
  (define (arith-op op expr1 expr2)
    (: Num->number : FLANG -> Number)
    (define (Num->number e)
      (cases e
        [(Num n) n]
        [else (error 'arith-op "expects a number, got: ~s" e)]))
    (Num (op (Num->number expr1) (Num->number expr2))))

We can also make things a little easier to use if we make `run' convert
the result to a number:

  (: run : String -> Number)
  ;; evaluate a FLANG program contained in a string
  (define (run str)
    (let ([result (eval (parse str))])
      (cases result
        [(Num n) n]
        [else (error 'run
                     "evaluation returned a non-number: ~s" result)])))

Adding few simple tests we get:

  ----------------------------------------------------------------------
  ;; The Flang interpreter

  #lang pl

  #|
  The grammar:
    <FLANG> ::= <num>
              | { + <FLANG> <FLANG> }
              | { - <FLANG> <FLANG> }
              | { * <FLANG> <FLANG> }
              | { / <FLANG> <FLANG> }
              | { with { <id> <FLANG> } <FLANG> }
              | <id>
              | { fun { <id> } <FLANG> }
              | { call <FLANG> <FLANG> }

  Evaluation rules:

    subst:
      N[v/x]                = N
      {+ E1 E2}[v/x]        = {+ E1[v/x] E2[v/x]}
      {- E1 E2}[v/x]        = {- E1[v/x] E2[v/x]}
      {* E1 E2}[v/x]        = {* E1[v/x] E2[v/x]}
      {/ E1 E2}[v/x]        = {/ E1[v/x] E2[v/x]}
      y[v/x]                = y
      x[v/x]                = v
      {with {y E1} E2}[v/x] = {with {y E1[v/x]} E2[v/x]} ; if y =/= x
      {with {x E1} E2}[v/x] = {with {x E1[v/x]} E2}
      {call E1 E2}[v/x]     = {call E1[v/x] E2[v/x]}
      {fun {y} E}[v/x]      = {fun {y} E[v/x]}           ; if y =/= x
      {fun {x} E}[v/x]      = {fun {x} E}

    eval:
      eval(N)            = N
      eval({+ E1 E2})    = eval(E1) + eval(E2)  \ if both E1 and E2
      eval({- E1 E2})    = eval(E1) - eval(E2)   \ evaluate to numbers
      eval({* E1 E2})    = eval(E1) * eval(E2)   / otherwise error!
      eval({/ E1 E2})    = eval(E1) / eval(E2)  /
      eval(id)           = error!
      eval({with {x E1} E2}) = eval(E2[eval(E1)/x])
      eval(FUN)          = FUN ; assuming FUN is a function expression
      eval({call E1 E2}) = eval(Ef[eval(E2)/x]) if eval(E1)={fun {x} Ef}
                         = error!               otherwise
  |#

  (define-type FLANG
    [Num  Number]
    [Add  FLANG FLANG]
    [Sub  FLANG FLANG]
    [Mul  FLANG FLANG]
    [Div  FLANG FLANG]
    [Id   Symbol]
    [With Symbol FLANG FLANG]
    [Fun  Symbol FLANG]
    [Call FLANG FLANG])

  (: parse-sexpr : Sexpr -> FLANG)
  ;; to convert s-expressions into FLANGs
  (define (parse-sexpr sexpr)
    (match sexpr
      [(number: n)    (Num n)]
      [(symbol: name) (Id name)]
      [(cons 'with more)
       (match sexpr
         [(list 'with (list (symbol: name) named) body)
          (With name (parse-sexpr named) (parse-sexpr body))]
         [else (error 'parse-sexpr "bad `with' syntax in ~s" sexpr)])]
      [(cons 'fun more)
       (match sexpr
         [(list 'fun (list (symbol: name)) body)
          (Fun name (parse-sexpr body))]
         [else (error 'parse-sexpr "bad `fun' syntax in ~s" sexpr)])]
      [(list '+ lhs rhs) (Add (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '- lhs rhs) (Sub (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '* lhs rhs) (Mul (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '/ lhs rhs) (Div (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list 'call fun arg) (Call (parse-sexpr fun) (parse-sexpr arg))]
      [else (error 'parse-sexpr "bad syntax in ~s" sexpr)]))

  (: parse : String -> FLANG)
  ;; parses a string containing a FLANG expression to a FLANG AST
  (define (parse str)
    (parse-sexpr (string->sexpr str)))

  (: subst : FLANG Symbol FLANG -> FLANG)
  ;; substitutes the second argument with the third argument in the
  ;; first argument, as per the rules of substitution; the resulting
  ;; expression contains no free instances of the second argument
  (define (subst expr from to)
    (cases expr
      [(Num n) expr]
      [(Add l r) (Add (subst l from to) (subst r from to))]
      [(Sub l r) (Sub (subst l from to) (subst r from to))]
      [(Mul l r) (Mul (subst l from to) (subst r from to))]
      [(Div l r) (Div (subst l from to) (subst r from to))]
      [(Id name) (if (eq? name from) to expr)]
      [(With bound-id named-expr bound-body)
       (With bound-id
             (subst named-expr from to)
             (if (eq? bound-id from)
               bound-body
               (subst bound-body from to)))]
      [(Call l r) (Call (subst l from to) (subst r from to))]
      [(Fun bound-id bound-body)
       (if (eq? bound-id from)
         expr
         (Fun bound-id (subst bound-body from to)))]))

  (: arith-op : (Number Number -> Number) FLANG FLANG -> FLANG)
  ;; gets a Racket numeric binary operator, and uses it within a FLANG
  ;; `Num' wrapper
  (define (arith-op op expr1 expr2)
    (: Num->number : FLANG -> Number)
    (define (Num->number e)
      (cases e
        [(Num n) n]
        [else (error 'arith-op "expects a number, got: ~s" e)]))
    (Num (op (Num->number expr1) (Num->number expr2))))

  (: eval : FLANG -> FLANG)
  ;; evaluates FLANG expressions by reducing them to *expressions*
  (define (eval expr)
    (cases expr
      [(Num n) expr]
      [(Add l r) (arith-op + (eval l) (eval r))]
      [(Sub l r) (arith-op - (eval l) (eval r))]
      [(Mul l r) (arith-op * (eval l) (eval r))]
      [(Div l r) (arith-op / (eval l) (eval r))]
      [(With bound-id named-expr bound-body)
       (eval (subst bound-body
                    bound-id
                    (eval named-expr)))]
      [(Id name) (error 'eval "free identifier: ~s" name)]
      [(Fun bound-id bound-body) expr]
      [(Call (Fun bound-id bound-body) arg-expr)
       (eval (subst bound-body
                    bound-id
                    (eval arg-expr)))]
      [(Call something arg-expr)
       (error 'eval "`call' expects a function, got: ~s" something)]))

  (: run : String -> Number)
  ;; evaluate a FLANG program contained in a string
  (define (run str)
    (let ([result (eval (parse str))])
      (cases result
        [(Num n) n]
        [else (error 'run
                     "evaluation returned a non-number: ~s" result)])))

  ;; tests
  (test (run "{call {fun {x} {+ x 1}} 4}")
        => 5)
  (test (run "{with {add3 {fun {x} {+ x 3}}}
                {call add3 1}}")
        => 4)
  (test (run "{with {add3 {fun {x} {+ x 3}}}
                {with {add1 {fun {x} {+ x 1}}}
                  {with {x 3}
                    {call add1 {call add3 x}}}}}")
        => 7)
  ----------------------------------------------------------------------

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

There is still a problem with this version.  First a question -- if
`call' is similar to arithmetic operations (and to `with' in what it
actually does), then how come the code is different enough that it
doesn't even need an auxiliary function?

Second question: what *should* happen if we evaluate these:

  (run "{with {identity {fun {x} x}}
          {with {foo {fun {x} {+ x 1}}}
            {call {call identity foo} 123}}}")
  (run "{call {call {fun {x} {call x 1}}
                    {fun {x} {fun {y} {+ x y}}}}
              123}")

Third question, what *will* happen if we do the above?

The following simple fix takes care of this:

  (: eval : FLANG -> FLANG)
  ;; evaluates FLANG expressions by reducing them to *expressions*
  (define (eval expr)
    (cases expr
      [(Num n) expr]
      [(Add l r) (arith-op + (eval l) (eval r))]
      [(Sub l r) (arith-op - (eval l) (eval r))]
      [(Mul l r) (arith-op * (eval l) (eval r))]
      [(Div l r) (arith-op / (eval l) (eval r))]
      [(With bound-id named-expr bound-body)
       (eval (subst bound-body
                    bound-id
                    (eval named-expr)))]
      [(Id name) (error 'eval "free identifier: ~s" name)]
      [(Fun bound-id bound-body) expr]
      [(Call fun-expr arg-expr)
       (let ([fval (eval fun-expr)])        ; <- need to evaluate this!
         (cases fval
           [(Fun bound-id bound-body)
            (eval (subst bound-body
                         bound-id
                         (eval arg-expr)))]
           [else (error 'eval "`call' expects a function, got: ~s"
                              fval)]))]))

The complete code is:

  ---<<<FLANG>>>--------------------------------------------------------
  ;; The Flang interpreter

  #lang pl

  #|
  The grammar:
    <FLANG> ::= <num>
              | { + <FLANG> <FLANG> }
              | { - <FLANG> <FLANG> }
              | { * <FLANG> <FLANG> }
              | { / <FLANG> <FLANG> }
              | { with { <id> <FLANG> } <FLANG> }
              | <id>
              | { fun { <id> } <FLANG> }
              | { call <FLANG> <FLANG> }

  Evaluation rules:

    subst:
      N[v/x]                = N
      {+ E1 E2}[v/x]        = {+ E1[v/x] E2[v/x]}
      {- E1 E2}[v/x]        = {- E1[v/x] E2[v/x]}
      {* E1 E2}[v/x]        = {* E1[v/x] E2[v/x]}
      {/ E1 E2}[v/x]        = {/ E1[v/x] E2[v/x]}
      y[v/x]                = y
      x[v/x]                = v
      {with {y E1} E2}[v/x] = {with {y E1[v/x]} E2[v/x]} ; if y =/= x
      {with {x E1} E2}[v/x] = {with {x E1[v/x]} E2}
      {call E1 E2}[v/x]     = {call E1[v/x] E2[v/x]}
      {fun {y} E}[v/x]      = {fun {y} E[v/x]}           ; if y =/= x
      {fun {x} E}[v/x]      = {fun {x} E}

    eval:
      eval(N)            = N
      eval({+ E1 E2})    = eval(E1) + eval(E2)  \ if both E1 and E2
      eval({- E1 E2})    = eval(E1) - eval(E2)   \ evaluate to numbers
      eval({* E1 E2})    = eval(E1) * eval(E2)   / otherwise error!
      eval({/ E1 E2})    = eval(E1) / eval(E2)  /
      eval(id)           = error!
      eval({with {x E1} E2}) = eval(E2[eval(E1)/x])
      eval(FUN)          = FUN ; assuming FUN is a function expression
      eval({call E1 E2}) = eval(Ef[eval(E2)/x]) if eval(E1)={fun {x} Ef}
                         = error!               otherwise
  |#

  (define-type FLANG
    [Num  Number]
    [Add  FLANG FLANG]
    [Sub  FLANG FLANG]
    [Mul  FLANG FLANG]
    [Div  FLANG FLANG]
    [Id   Symbol]
    [With Symbol FLANG FLANG]
    [Fun  Symbol FLANG]
    [Call FLANG FLANG])

  (: parse-sexpr : Sexpr -> FLANG)
  ;; to convert s-expressions into FLANGs
  (define (parse-sexpr sexpr)
    (match sexpr
      [(number: n)    (Num n)]
      [(symbol: name) (Id name)]
      [(cons 'with more)
       (match sexpr
         [(list 'with (list (symbol: name) named) body)
          (With name (parse-sexpr named) (parse-sexpr body))]
         [else (error 'parse-sexpr "bad `with' syntax in ~s" sexpr)])]
      [(cons 'fun more)
       (match sexpr
         [(list 'fun (list (symbol: name)) body)
          (Fun name (parse-sexpr body))]
         [else (error 'parse-sexpr "bad `fun' syntax in ~s" sexpr)])]
      [(list '+ lhs rhs) (Add (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '- lhs rhs) (Sub (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '* lhs rhs) (Mul (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list '/ lhs rhs) (Div (parse-sexpr lhs) (parse-sexpr rhs))]
      [(list 'call fun arg) (Call (parse-sexpr fun) (parse-sexpr arg))]
      [else (error 'parse-sexpr "bad syntax in ~s" sexpr)]))

  (: parse : String -> FLANG)
  ;; parses a string containing a FLANG expression to a FLANG AST
  (define (parse str)
    (parse-sexpr (string->sexpr str)))

  (: subst : FLANG Symbol FLANG -> FLANG)
  ;; substitutes the second argument with the third argument in the
  ;; first argument, as per the rules of substitution; the resulting
  ;; expression contains no free instances of the second argument
  (define (subst expr from to)
    (cases expr
      [(Num n) expr]
      [(Add l r) (Add (subst l from to) (subst r from to))]
      [(Sub l r) (Sub (subst l from to) (subst r from to))]
      [(Mul l r) (Mul (subst l from to) (subst r from to))]
      [(Div l r) (Div (subst l from to) (subst r from to))]
      [(Id name) (if (eq? name from) to expr)]
      [(With bound-id named-expr bound-body)
       (With bound-id
             (subst named-expr from to)
             (if (eq? bound-id from)
               bound-body
               (subst bound-body from to)))]
      [(Call l r) (Call (subst l from to) (subst r from to))]
      [(Fun bound-id bound-body)
       (if (eq? bound-id from)
         expr
         (Fun bound-id (subst bound-body from to)))]))

  (: arith-op : (Number Number -> Number) FLANG FLANG -> FLANG)
  ;; gets a Racket numeric binary operator, and uses it within a FLANG
  ;; `Num' wrapper
  (define (arith-op op expr1 expr2)
    (: Num->number : FLANG -> Number)
    (define (Num->number e)
      (cases e
        [(Num n) n]
        [else (error 'arith-op "expects a number, got: ~s" e)]))
    (Num (op (Num->number expr1) (Num->number expr2))))

  (: eval : FLANG -> FLANG)
  ;; evaluates FLANG expressions by reducing them to *expressions*
  (define (eval expr)
    (cases expr
      [(Num n) expr]
      [(Add l r) (arith-op + (eval l) (eval r))]
      [(Sub l r) (arith-op - (eval l) (eval r))]
      [(Mul l r) (arith-op * (eval l) (eval r))]
      [(Div l r) (arith-op / (eval l) (eval r))]
      [(With bound-id named-expr bound-body)
       (eval (subst bound-body
                    bound-id
                    (eval named-expr)))]
      [(Id name) (error 'eval "free identifier: ~s" name)]
      [(Fun bound-id bound-body) expr]
      [(Call fun-expr arg-expr)
       (let ([fval (eval fun-expr)])
         (cases fval
           [(Fun bound-id bound-body)
            (eval (subst bound-body
                         bound-id
                         (eval arg-expr)))]
           [else (error 'eval "`call' expects a function, got: ~s"
                              fval)]))]))

  (: run : String -> Number)
  ;; evaluate a FLANG program contained in a string
  (define (run str)
    (let ([result (eval (parse str))])
      (cases result
        [(Num n) n]
        [else (error 'run
                     "evaluation returned a non-number: ~s" result)])))

  ;; tests
  (test (run "{call {fun {x} {+ x 1}} 4}")
        => 5)
  (test (run "{with {add3 {fun {x} {+ x 3}}}
                {call add3 1}}")
        => 4)
  (test (run "{with {add3 {fun {x} {+ x 3}}}
                {with {add1 {fun {x} {+ x 1}}}
                  {with {x 3}
                    {call add1 {call add3 x}}}}}")
        => 7)
  (test (run "{with {identity {fun {x} x}}
                {with {foo {fun {x} {+ x 1}}}
                  {call {call identity foo} 123}}}")
        => 124)
  (test (run "{call {call {fun {x} {call x 1}}
                          {fun {x} {fun {y} {+ x y}}}}
                    123}")
        => 124)
  ----------------------------------------------------------------------

========================================================================
>>> Introducing Racket's `lambda'

fun & lambda
difference between lambda and simple values
Racket puzzle -- (+ ((?)) 3)
not being able to do recursive functions with `let'
let* as a derived form
let with lambda in Racket --> can be a derived form
how `if' can be used to implement `and' `or' as derived forms

Newtonian syntax vs. a lambda expression.

Don't be fooled into making a bogus connection between Racket's syntax,
and its `unique' powers...  The fact is that it is not the only language
that has this capability.  For example, this:

  (define (f g) (g 2 3))
  (f +) ==> 5
  (f *) ==> 6
  (f (lambda (x y) (+ (square x) (square y)))) ==> 13

Can be written in JavaScript like this:

  function f(g) { return g(2,3); }
  function square(x) { return x*x; }
  window.alert(f(function (x,y) { return square(x) + square(y); }))

In Perl:

  sub f { my ($g) = @_; return $g->(2,3); }
  sub square { my ($x) = @_; return $x * $x; }
  print f(sub { my ($x, $y) = @_; return square($x) + square($y); });

In Ruby:

  def f(g) g.call(2,3) end
  def square(x) x*x end
  puts f(lambda{|x,y| square(x) + square(y)});

etc.  Even C++ has lambda expressions:

  http://www2.research.att.com/~bs/C++0xFAQ.html#lambda

========================================================================
>>> Using Functions as Objects

A very important aspect of Racket -- using "higher order" functions --
functions that get and return functions.  Here is a very simple example:

  (define (f x) (lambda () x))
  (define a (f 2))
  (a)  -->  2
  (define b (f 3))
  (b)  -->  3

Note: what we get is actually an object that remembers (by the
substitution we're doing) a number.  How about:

  (define aa (f a))
  (aa)    -->  #<procedure> (this is a)
  ((aa))  -->  2

Take this idea to the next level:

  (define (kons x y)
    (lambda (b)
      (if b x y)))
  (define (kar x) (x #t))
  (define (kdr x) (x #f))
  (define a (kons 1 2))
  (define b (kons 3 4))
  (list (kar a) (kdr a))
  (list (kar b) (kdr b))

Or, with types:

  (: kons : (All (A B) A B -> (Boolean -> (U A B))))
  (define (kons x y)
    (lambda (b)
      (if b x y)))
  (: kar : (All (T) (Boolean -> T) -> T))
  (define (kar x) (x #t))
  (: kdr : (All (T) (Boolean -> T) -> T))
  (define (kdr x) (x #f))
  (define a (kons 1 2))
  (define b (kons 3 4))
  (list (kar a) (kdr a))
  (list (kar b) (kdr b))

Even more -- why should the internal function expect a boolean and
choose what to return?  We can simply expect a function that will take
the two values and return one:

  (define (kons x y)
    (lambda (s)
      (s x y)))
  (define (kar x) (x (lambda (x y) x)))
  (define (kdr x) (x (lambda (x y) y)))
  (define a (kons 1 2))
  (define b (kons 3 4))
  (list (kar a) (kdr a))
  (list (kar b) (kdr b))

And a typed version, using our own constructor to make it a little less
painful:

  (define-type (Kons A B) = ((A B -> (U A B)) -> (U A B)))

  (: kons : (All (A B) A B -> (Kons A B)))
  (define (kons x y)
    (lambda (s)
      (s x y)))
  (: kar : (All (A B) (Kons A B) -> (U A B)))
  (define (kar x) (x (lambda (x y) x)))
  (: kdr : (All (A B) (Kons A B) -> (U A B)))
  (define (kdr x) (x (lambda (x y) y)))
  (define a (kons 1 2))
  (define b (kons 3 4))
  (list (kar a) (kdr a))
  (list (kar b) (kdr b))

Note that the `Kons' type definition is the same as:

  (define-type Kons = (All (A B) (A B -> (U A B)) -> (U A B)))

so `All' is to polymorphic type definitions what `lambda' is for
function definitions.

Finally in JavaScript:

  function kons(x,y) {
    return function(s) { return s(x, y); }
  }
  function kar(x) { return x(function(x,y){ return x; }); }
  function kdr(x) { return x(function(x,y){ return y; }); }
  a = kons(1,2);
  b = kons(3,4);
  window.alert('a = <' + kar(a) + ',' + kdr(a) + '>' );
  window.alert('b = <' + kar(b) + ',' + kdr(b) + '>' );

========================================================================
>>> Currying

A "curried" function is a function that, instead of accepting two (or
more) arguments, accepts only one and returns a function that accepts
the rest.  For example:

  (: plus : Number -> (Number -> Number))
  (define (plus x)
    (lambda (y)
      (+ x y)))

It's easy to write functions for translating between normal and curried
versions.

  (define (currify f)
    (lambda (x)
      (lambda (y)
        (f x y))))

Typed version of that, with examples:

  (: currify : (All (A B C) (A B -> C) -> (A -> (B -> C))))
  ;; convert a double-argument function to a curried one
  (define (currify f)
    (lambda (x) (lambda (y) (f x y))))

  (: add : Number Number -> Number)
  (define (add x y) (+ x y))

  (: plus : Number -> (Number -> Number))
  (define plus (currify add))

  (test ((plus 1) 2) => 3)
  (test (((currify add) 1) 2) => 3)
  (test (map (plus 1) '(1 2 3)) => '(2 3 4))
  (test (map ((currify add) 1) '(1 2 3)) => '(2 3 4))
  (test (map ((currify +) 1) '(1 2 3)) => '(2 3 4))

Usages -- common with H.O. functions like map, where we want to `fix'
one argument.

When dealing with such higher-order code, the types are very helpful,
since every arrow corresponds to a function:

  (: currify : (All (A B C) (A B -> C) -> (A -> (B -> C))))

It is common to make the `->' function type associate to the right, so
you can find this type written as:

  currify : (A B -> C) -> (A -> B -> C)

or even as

  currify : (A B -> C) -> A -> B -> C

but that can be a little confusing...

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