The Little Schemer speedy referring note (3/3)

Posted by Katherine's Blog on Monday, January 6, 2020

TOC

Part one: The Little Schemer speedy referring note (13)-Katherine He Blog|何琪的博客 Part two: The Little Schemer speedy referring note (23)-Katherine He Blog|何琪的博客 Part three: The Little Schemer speedy referring note (33)-Katherine He Blog|何琪的博客

This is a quick reference note that I pull from the book The Little Schemer. The code in this note is from here with edition:

the-little-schemer/02-do-it-again.ss at master · pkrumins/the-little-schemer

The former chapters can be easily understood from reading the code without counting parenthesis. However from this chapter, it is highly recommended to download Drracket and use a stepper to run all the recurions. For example, the stepper make the answer of soegaard very straightforward:

scheme - Y combinator discussion in “The Little Schemer” - Stack Overflow

This chapter introduces the idea of Y combinator based on recursion. We’ve seen that recursion is a function calling itself during defining itself, but when the function is just an lambda expression without name, what do we do?

The Y combinator provides a solution by designing an high order function, which is a function that takes a function as an argument and returns a function. Taking factorial as an example, we deduce a function G where G(factorial)=factorial. Let’s learn how to deduce step by step.

Chapter 9 and Again and Again and Again

The key of writing recursion is making sure there is termination condition. That’s the basic requirement for function in both computation and mathmatics area: a function is a mapping procedure which takes in an argument and produces an output accordingly. We need to aviod any algorithm leading to infinite loop.

Here is an example of failed design: the (keep-looking) calls (pick) to see if a is equal to the random atom in lat (assuming the numbers in lat is random).

;pick return n-th element in lat:
(define pick
  (lambda (n lat)
    (cond
      ((zero? (sub1 n)) (car lat))
      (else
        (pick (sub1 n) (cdr lat))))))

(define keep-looking
  (lambda (a sorn lat)
    (cond
      ((number? sorn)
       (keep-looking a (pick sorn lat) lat))
      (else (eq? sorn a )))))

(define looking
  (lambda (a lat)
    (keep-looking a (pick 1 lat) lat)))

; Example of looking
(looking 'caviar '(6 2 4 caviar 5 7 3))         ; #t
(looking 'caviar '(6 2 grits caviar 5 7 3))     ; #f

In the first test case we can find that, the 'caviar is the 4th element in the first example, and the list contains 4. So running it is very likely to hit the termination condition. But in second example the 'caviar is the 4th element whereas no 4 is contained in the list, so the recursion will run forever, meaning the function won’t always return a value for an input. This illed function is called partial function as opposed to total function defined previously.

Let’s see another example. We’ve defined pair is a list containing two s-expressions (s-expression: a binary tree). The shift takes a pair whose first component is a pair and builds a pair by shifting the second part of the first component into the second component.

(define first
  (lambda (p)
    (car p)))

(define second
  (lambda (p)
    (car (cdr p))))

(define build
  (lambda (s1 s2)
    (cons s1 (cons s2 '()))))

;(shift '((a b) c)) -> '(a (b c))
;(shift '((a b) (c d))) -> '(a (b (c d)))
(define shift
  (lambda (pair)
    (build (first (first pair))
      (build (second (first pair))
        (second pair)))))

(define a-pair?
  (lambda (x)
    (cond
      ((atom? x) #f)
      ((null? x) #f)
      ((null? (cdr x)) #f)
      ((null? (cdr (cdr x))) #t)
      (else #f))))

(define align
  (lambda (pora)
    (cond
      ((atom? pora) pora)
      ((a-pair? (first pora))
       (align (shift pora))) ;******alarming
      (else (build (first pora)
              (align (second pora)))))))

Based on (shift) we further creat (align). Don’t rush to run the function. Remember the seventh commandment emphasizes “recursion should happen on the subparts that are of the same nature: either on the sublists of a list; or on the subexpressions of an arithmetic expression”. We notice something alarming in the starred line in (align): the (align) as well as (keep-looking) both creat new argument in recursion that is not part of the original argument. It’s an indicator of ill, but (align) will still generate output for every input, so it’s not partial function.

We will continue and define a very similar function (shuffle) below, which is partial. It won’t produce value for some cases, since the a-pair predicate will always swap the items of pair, which makes any input with form of ((a b) (c d)) trapped in infinite item swapping loop.

;(revpair '((a b) (c d))) -> ((c d) (a b))
(define revpair
  (lambda (p)
    (build (second p) (first p))))

(define shuffle
  (lambda (pora)
    (cond
      ((atom? pora) pora)
      ((a-pair? (first pora))
       (shuffle (revpair pora)))
      (else
        (build (first pora)
          (shuffle (second pora)))))))

(shuffle '(a (b c)))        ; '(a (b c))
(shuffle '(a b))            ; '(a b)
(shuffle '((a b) (c d)))    ; infinite swap pora  Ctrl + c  to break and input q to exit

We just define two different ways to measure the mass of the first component of (align). The (length*) measures every atom with same weight, whereas the (weight*) puts twice as much weight to the first component.

(define length*
  (lambda (pora)
    (cond
      ((atom? pora) 1)
      (else
        (+ (length* (first pora))
           (length* (second pora)))))))
;(length* '((a b) c)) -> 3
;(length* '(a (b c)) -> 3

(define weight*
  (lambda (pora)
    (cond
      ((atom? pora) 1)
      (else
        (+ (* (weight* (first pora)) 2)
           (weight* (second pora)))))))
;(weight* '((a b) c)) -> 7
;(weight* '(a (b c)) -> 5

From (align) and (shuffle), we realize that whether the arguments will decrease in recursion is not the key to infer whether a function is total. We start to think if possible to develop a diagnose function to detect the partial function. Let’s imaging making up a function (will-stop?) without getting into detail. We want it to return #t if the function would eventually terminate with returning value, and return #f it does not stop. And itself has to be a total function, in which case (will-stop? will-stop>) has to return #t.

What would happen if the input are (length) and (eternity) like these? Sounds cool: the (length) stops when the input is '(), so the (will-stop?) returns #t, great! Meanwhile the (eternity) is partial and won’t stop for any input, which makes the (will-stop?) returns #f whatsoever.

(define eternity
  (lambda (x)
    (eternity x)))

(define will-stop?
  (lambda (x)
    (eternity x)))

(define length
  (lambda (lat)
    (cond
      ((null? lat) 0)
      (else (add1 (length (cdr lat)))))

(define will-stop?
  (lambda (x)
    (length x)))

But you might also sense logical flaws already: if there is a function can make (will-stop?) return #t but won’t stop, the partial function detection function may eventually NOT exist. If you cannot, the author has carefully come up with an example to show why.

Let’s see this example:

(define last-try
 (lambda (x)
  (and (will-stop? last-try)
    (eternity x))))

In order to test if ths is a right function, we input () and that requires evaluate (will-stop? last-try). Provided it returns #f (aka the last-try will not stop with null input), then the whole function will stop and return #f. Clearly this mother function (last-try (quote())) stops for null input, which goes against the aka part in parenthesis. So we try the opposite hypothesis: it returns #t (aka the last-try will stop with null input), and then we get to evaluate (eternity (quote())), which never stops. And this time, it logically goes against the hypothesis again. This makes the (will-stop?) a function we can describe but can not define. The example delicately demonstrates this by constructing a function based on (will-stop?) which (will-stop?) cannot judge.

You might ask what if we just ban the logical contradiction part, such as “preventing tested function from directly or indirectly calling (will-stop?)”. In that case, will (will-stop?) exist? I am not sure. But that “using functions without recursively calling itself” is exactly what we want to do with the Y combinator.


A function calling itself directly or indirectly, is recursion. A nature wonder about recursion is that, if we want to call a function that haven’t been fully defined, how could we do it?

There are many ways to write programs to realize the same procedure. But a specific interpreter has clear rule to implement a function. In this chapter, we can use transformations and derivations to gain fundamental understanding of nested functions, to peel off the syntax sugar so that we can reform them to design elegant form.

We probably can re-write a recursive function to non-recursive one, then we can use it as much as we want. That’s what the Y combinator is for.

Let’s begin with recursive function we have seen, to see what part we can get rid of and reform. We still use (length) as an example. Currently it is a fully defined function recursive function. The input is a list and the output is a value (i.e. the length of a list). It can use recursion inside itself because it has formal function name length.

;you have use to other name in DrRacket, coz length has been a build-in function
(define length
 (lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (length (cdr l)))))))

(length '(a b)) ;-> 2

I highlight four key procedures to show how it adapts:

The thing about the recursion (length) is, it may look like the (length) is calling itself. More broadly speaking, it is just calling a function happens to have the same name with itself. The function will be used when the input (cdr l) is not null. It can be any functions, so you can try substituting (length) with any function you like. This equals to having another layer of lambda expression to the function of (length):

(lambda (length)
  (lambda (l)
    (cond ((null? l) 0)
      (else (+ 1 (length (cdr l)))))))

Notice, you can try inputting any function in outer layer but most functions will not work with non-null input list. For example let’s call (eternity) instead of (length): when the list has more than zero atom, the null predicate returns #f and (eternity '()) will be called and the function will trap in infinite loop.

;((lambda (length) ..) eternity)
;length<=0
(lambda (l)
    (cond
      ((null? l) 0)
      (else
        (add1 (eternity (cdr l))))))

It can still measure null list only in the applicative order interpreting, where the arguments will be instantaneously evaluated the leftmost innermost reducible expression before the function is applied.

But there is still a way to measure list with less than one element. We just have to call length measuring function on top of (length0) one more time.

;length<=1
(lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (length0 (cdr l))))))

;length<=1
(lambda (l)  ;read more details below if you don't understand here
  (cond
    ((null? l) 0)
    (else
      (add1
        ((lambda(l)
           (cond
             ((null? l) 0)
             (else
               (add1 (eternity (cdr l))))))
         (cdr l))))))

Recursively we can develop (length<=2) below. Can you explain why these three functions are identical?

;length<=2
(lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (length1 (cdr l))))))

(lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1
        ((lambda(l)
           (cond
             ((null? l) 0)
             (else
               (add1 (length0 (cdr l))))))
         (cdr l))))))

(lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1
        ((lambda(l)
           (cond
             ((null? l) 0)
             (else
               (add1
                ((lambda(l)
                 (cond
                   ((null? l) 0)
                     (else
                       (add1 (eternity (cdr l))))))
               (cdr l))))))
      (cdr l))))))

;let's give distinguished names to arguments in every layer
(lambda (l2)  ;assume l2 = '(b c)
  (cond
    ((null? l2) 0)
    (else
      (add1
        ((lambda(l1)  ;then l1 <- cdr(l2) = '(c)
           (cond
             ((null? l1) 0)
             (else
               (add1
                ((lambda(l0)  ;then l0 <- cdr(l1) = '( )
                 (cond
                   ((null? l0) 0)  ;so here returns 0, and terminates
                     (else
                       (add1 (eternity (cdr l0))))))
               (cdr l1))))))
      (cdr l2))))))

As you might imagine, the above form is not quite complete, so we were only saying its got a “hidden layer of parameter”. Let’s make it slightly more formal by separating (eternity) and calling it as argument. In the (length<=1) code we just want to use distinctive names for you to see this procedure clearer.

;length<=0
((lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (length (cdr l)))))))
 eternity)

;length<=1
((lambda (f)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (f (cdr l)))))))
 ((lambda (g)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (g (cdr l)))))))
  eternity))

;length<=2
((lambda (length)
  (lambda(l)
   (cond)
       ((null? l) 0)
       (else (add1 (length (cdr l)))))))
 ((lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l)))))))
 ((lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l)))))))
  eternity)))

It’s absolutely normal to get confused when there are more layers of lambda expressions involved in a function/recursion. It helps to think whether the lambda expressions is being merely defined or being defined and called, i.e. counting the parenthesis very carefully. The difference between defining and calling is that calling a function has arguments involved:

;defining
(lambda (f)
  (lambda (g)...)
)

;calling(f) with defining(g)
((lambda (f)
  (lambda (g)...))
    arguments-for-f)

A more general case of calling with defining in lambda expression is called the omega combinator. It has shape in the below picture and more information can be found at Lambda calculus - Wikipedia

The above functions show repetitive content: the (length) part is being called over and over, working on a shorter and shorter argument. Normally, we would write and save as a named function for calling in the future like (define length). But, if we don’t save it, instead we want to directly address it within other function, or even address itself. How do we do that?

You may have realized the motivation of this question, addressing itself withing itself is exactly the nature of recursion. In this chapter we just want to find a good way to do it for anonymous functions.

If we can define length abstractly, we can call it to simplify the reptitive procedure. This need is particularly necessary when there is going to be many algorithms having similar repetitions as (length<=n).

Ok, we are finally reaching the core reforming step. We are giving the formal calling form as equivalent to (define length):

(define length
 (lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (length (cdr l)))))))

(length '( )) ;-> 0
(length '(a b)) ;-> 2
;--------------------------------------------
((lambda (mk-length)
  (mk-length eternity))
 (lambda (length)
  (lambda(l)
   (cond
 ((null? l) 0)
  (else (add1 (length (cdr l))))))))

((mk-length eternity) '());-> 0
((mk-length eternity) '(a));-> error

From the above we can see instead of being a name defined by define, length can also work as an parameter/argument.

However there is a major difference: (define length) has only one lambda expression, the input must be a list and the output is value. But the anonymous definition is adding another layer of lambda expression, the input and output for the outer lambda expression (i.e. the whole function) will have to be functions. It’s the output “function (λ l)” that will return value like the defined length function.

Another very important note is that, the (define length) function can evalue list with any length. the anonymous function can only evaluate input of null list, why? Because the input for length must be function ((cdr l) sure won’t fit), so if we don’t want get error message, it will have to terminate at (null? l) stage. Like we said, we will have to use call function more times if we want to measure longer lists:

;length<=1
((lambda (mk-length)
 (mk-length
 (mk-length eternity)))
 (lambda (length)
  (lambda(l)
   (cond
 ((null? l) 0)
  (else (add1 (length (cdr l))))))))

;length<=2
((lambda (mk-length)
  (mk-length
   (mk-length
    (mk-length eternity))))
 (lambda (length)
  (lambda(l)
   (cond
 ((null? l) 0)
  (else (add1 (length (cdr l))))))))

In the (length<=0) function the only working part is ((null? l) 0) and the (else) predicate would never got triggered. So in that predicate it doesn’t really matter whether we call function (eternity), or itself (mk-length). We just change (eternity) to (mk-length):

; length<=0
((lambda (mk-length)
   (mk-length mk-length)) ;<- we change here
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else
         (add1 (length (cdr l))))))))

The above code is still ONLY able to measure null list, because for other input, it will have to expand (add1 (length (cdr l))) where the input of argument has to be a function, defined by the (lambda (mk-length)(mk-length mk-length). But the input (cdr l) is a list. See how it fails in stepper:

As you might guess, we can just pass a random/any function to make it successfully measure the length one list, since it will stop in (null? list) in the second loop. For example any of these three functions could work:

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else
         (add1 ((length add1) (cdr l))))))))

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else
         (add1 ((length eternity) (cdr l))))))))

;This one is fundamentally different from the above two, why?
((lambda (mk-length)
   (mk-length mk-length))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else
         (add1 ((length length) (cdr l))))))))

The former two functions can only help you measure length one list. For length two input it would fail in the function expansion, resulting in non-legitimate functions (add1 add1) (eternity eternity) in the second loop. However, the third one won’t fail because (length length) is a legitimate function, it can help us measure list with any length. So functionally speaking, these two are finally consistent:

(define length
 (lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (length (cdr l)))))))

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else
         (add1 ((length length) (cdr l))))))))

All left job is just to make things extremely pithy. Let’s adding some syntax sugar here: since it doesn’t matter what we name the inner arguments, because it’s just an pseudo name inside a function. So we can name it anything as long as we keep naming and calling consistent. The last function above can be written as:

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else
         (add1 ((mk-length mk-length) (cdr l))))))))

The exercise in page 166 will help you on how it works. The instruction can be found in the answer of soegaard : scheme - Y combinator discussion in “The Little Schemer” - Stack Overflow

When running it with stepper in DrRacket, there are 27 steps for a case (l is (' a b c)), I only demonstrate 4 steps here (press ctrl and + to see the enlarged image)

You can try to play with longer list, such as this:

(((lambda (mk-length)
    (mk-length mk-length))
  (lambda (mk-length)
    (lambda (l)
      (cond
        ((null? l) 0 )
        (else (add1
               ((mk-length mk-length)
                (cdr l))))))))
 '(a b c)) ;<- it works with lists in any length, try it

You would realize that this is just more recurrences of that “bear in mind” picture, aka calling (mk-length mk-length) one more time before applying a shorter candidate list, until the (cdr l) runs out of atom. In the end, the null list becomes the termination condition, without triggering it, we will go stack overflow by calling (mk-length mk-length) infinite times.

If you find it confusing, read this preview of omega combinator in the first answer of this post:scheme - Y combinator discussion in “The Little Schemer” - Stack Overflow

Let’s further abstract the function with the legitimate though interrupting (mk-length mk-length) part. Simple, just add another layer, I add some syntax salt (mk-length-two) to distinguish with the original (mk-length i.e. mk-length-one) so you can see it clearer:

((lambda (mk-length)
   (mk-length mk-length))
 (lambda (mk-length-two)
   ((lambda (mk-length-one)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (mk-length-one (cdr l)))))))
   (lambda (l)
     ((mk-length-two mk-length-two) l)))))

Then we add one last more layer, (I swear it’s the last layer) to switch the order a bit, moving the actual length measuring part to make it look nicer:

((lambda (mk-length-one)
   ((lambda (mk-length)
      (mk-length mk-length))
    (lambda (mk-length-two)
      (mk-length-one (lambda (l)
            ((mk-length-two mk-length-two) l))))))
 (lambda (mk-length-one)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (mk-length-one (cdr l))))))))

That’s very complex, let’s simplify it

((lambda (f)
   ((lambda (x) (x x))
    (lambda (x)
      (f (lambda (l)
            ((x x) l))))))
 (lambda (mk-length-one)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (add1 (mk-length-one (cdr l))))))))

Define and name the first part as Y combinator

(define Y
 (lambda (f)
   ((lambda (x) (x x))
    (lambda (x)
      (f (lambda (l)
            ((x x) l)))))))

;and call Y with any function you want
((Y
 (lambda (len)
   (lambda (l)
     (cond
       ((null? l) 0)
       (else (+ 1 (len (cdr l)))))))) '(a b c d))

Done. Happy hacking!

Chapter 10 What is the value of all of this?

Firstly this chapter defines entry and table/enviroment. An entry consists of a pair of lists of equal length (length is the number of first level atoms in a list). A list of entries is table/environment.

The entries can be built by (cons) lists.

; Let's build entries with build from chapter 7 (07-friends-and-relations.ss)
(define build
  (lambda (s1 s2)
    (cons s1 (cons s2 '()))))

(define new-entry build)

; Test it out and build the example entries above
(build '(appetizer entree bevarage)
       '(pate boeuf vin))

We are using entries and tables to write an interpreter in this chapter, which refers to find names with matching values. So in our interested entry, the first list is usually a set of names, and the second list is a set of values corresponding to every names.

Given a function (lookup-in-entry), we would be able to find a value for every name.

;(lookup-in-entry name entry)

;food --
'((appetizer entree bevarage)
  (pate boeuf vin))

(lookup-in-entry entree food)
; -> boeuf

Let’s try writing it. The (lookup-in-entry) works this way: the (eq?) checks input with every element in name lists, and return the corresponding value in the second list. (Remember we always need to return ('()) first if the input is null.)

;(define second
;  (lambda (p)
;    (car (cdr p))))

;the entry-f take null λ function to make it not break
(define lookup-in-entry
  (lambda (name entry entry-f)
    (lookup-in-entry-help
      name
      (first entry)
      (second entry)
      entry-f)))

; lookup-in-entry uses lookup-in-entry-help helper function
(define lookup-in-entry-help
  (lambda (name names values entry-f)
    (cond
      ((null? names) (entry-f name))
      ((eq? (car names) name) (car values))
      (else
        (lookup-in-entry-help
          name
          (cdr names)
          (cdr values)
          entry-f)))))

; Let's try out lookup-in-entry
(lookup-in-entry
  'entree
  '((appetizer entree bevarage) (pate boeuf vin))
  (lambda (n) '()))
;-> boeuf

; The null function make sure the function doesn't break with incorrect input.
(lookup-in-entry
  'no-such-item
  '((appetizer entree bevarage) (pate boeuf vin))
  (lambda (n) '()))
;-> '()

Putting the above code to DrRacket and run with stepper, you can see how things are achieved.

The table/environment can be extended by adding more new pairs (aka entries) on top of the old table/entries.

(define extend-table cons)

We can write another (lookup-in-entry) working as above But notice the take the (car (cdr table)) as input in every recursions, which means the function will immediately cease and return value when the first name matches the input.

; lookup-in-table finds an entry in a table
(define lookup-in-table
  (lambda (name table table-f)
    (cond
      ((null? table) (table-f name))
      (else
        (lookup-in-entry
          name
          (car table)
          (lambda (name)
            (lookup-in-table
              name
              (cdr table)
              table-f)))))))

; Let's try lookup-in-table
(lookup-in-table
  'beverage
  '(((entree dessert) (spaghetti spumoni))
    ((appetizer entree beverage) (food tastes good)))
  (lambda (n) '()))
; -> 'good

Then let’s look at value and type. When asking what’s the value of an S-expression, in most of the cases, it returns the nature of itself. For example, see the value of these S-expression:

(value e) where e is (car (quote (a b c)))
; is a, coz the first element of '(a b c) is an atom

(value e) where e is (quote (car (quote (a b c))))
; is (car (quote (a b c)))
; coz (quote()) make the whole argument literal as a list
; the inner car won't be called.

(value e) where e is
((lambda (nothing)
  (cond
     (nothing (quote something))
     (else (quote nothing))))
#t)
;is something
;coz the e is evaluated first, returned 'something
;'something is an atom

What is type? Based on the working essence, all the functions we have seen in this book can be described in six types: (const, quote, identifier, lambda, cond, application). In interpreting program, implementing a type classification function in the first step is an efficiency booster. Because functions in the same type work in similar way. If we can write an universal function for each type, we can call and optimize each function based on their distinctive characteristics.

The similar part of interpretation is, recognizing the type and arguments of function, finding the corresponding value for each type and arguments (use (lookup-in-table)), then implementing the value to the type and arguments.

So firstly let’s how the type classification works. The first layer of classifier is (expression-to-action) and followed by other more detailed ones. This is going to be the most important function in this chapter: it classifies any input into the above six categories based on the “nature of action” of the input. Then each categories has its own running/interpreting rules with starred names (e.g. *const, *identifier). With these starred functions, we can roughly find values for anything, with a proper table.

Since everything can be classified with the above function, we can use (meaning e table) to find value for both functions and arguments, and merge the type and value together in a table to further writing implementing procedure. The above tree code blocks can be linked by two functions as:

; The value function takes an expression and evaulates it
(define value
  (lambda (e)
    (meaning e '())))

; The meaning function translates an expression to its meaning
(define meaning
  (lambda (e table)
    ((expression-to-action e) e table)))

Most of the running rules for the six categories are just writing down details of its working nature. And the examples on book are easy to follow. We will see some difficult ones together: *lambda, *cond, *application.

(1) lambda

We can see that e as an lambda expression, when passed to (meaning e table) it got classified as *lambda. The following rule of *lambda action defines e as non-primitive and attaches the table to its remainder. Later we will see in (apply-closure), for a function defined as non-primitive, we will further deconstruct the content of itself to run.

(2) cond

The rule for (*cond) category is similar to lambda. As we know an eternal condition of (cond) is (else) so it’s the first one got translated into meaning. The other predicates conditions of cond (cond-lines-of e) do not have much varieties either, no much more than (atom? eq? null? zero? o< o>) with combinations of (and or). These primitive ones got translated in the second predicate with meaning of (*const) from the (atom-to-action). The remaining non-usual ones which either goes to atom/identifier or got translated into (*application).

If you wonder, put the book example in DrRacket:

(*cond (cond (coffee klatsch)(else party))
  (((coffee)(#t))
   ((klatsch party)(5 (6)))))

And my answer: The coffee example roughly shows an idea of searching function for meaning/action in the table when it’s not primitive like (eq?).

(3) application

This category processes all other complex function expressions. For example, a S-expression applying value to a lambda function.

Starting from a simple example, implementing a lambda expression, is equal to find the meaning of an e with a table like this:

It equals evaluating =(*application (cons x y) table) too. We are not sure what kind of tables will always work, but We would like to have an universal form to do this, maybe with a closure that got functions, arguments and corresponding values stored in a structural form. Evaluating any non-primitive function would be like evaluating the meaning/*application of a standard object.

In fact yes, it is achievable. As is mention in *lambda part, applying a non-primitive function - a closure - to a list of values is the same as finding the meaning of the closure’s body with its table extended by an entry of the form (formals values). In this entry, formals is the formals of the closure and values is the results of evlis.

There may be a thousand possible closures, but let’s start with a simple one matching a function with known form.

This is how it evolves:


comments powered by Disqus