Note that the first part, about placeholders, explains why we see the test output as we do, when we write (times-served empty) = 0. Note that a slightly nicer way to write your test cases could be: (= (times-served empty) 0). (What would print out?)

Note anything familiar? The rules of evaluation are recursive. If you wanted, you could make your own data definitions to represent (your versions of) numbers, placeholders, function-call, and define; then you could use the design recipe, and write a scheme evaluator -- the core of drscheme -- yourself! (After seeing mutually-recursive data structures next week, this is a reasonable week-4 scheme homework.) Elegance speaks for itself!

Note: Over the rest of the semester, we will learn (just) three more special forms. (The formal definition of the corresponding part of C++ or Java requires about dense 30 pages, instead of 1. Those specifications have also been found to contain inconsistencies and errors, which have taken a long time to get revised.)

Digression: the proper use of quotation marks.

The Law of Scheme -- Special Forms

• The Law of define
  Two versions:
  • Syntax: (define placeholder exp).
    Meaning: Evaluate exp to get a value val. Then, whenever you are asked to evaluate placeholder, it will evaluate to the val.
    Why special form: What if we tried this as a normal function?
  • Syntax: (define (placeholder ..args..) body-exp).
    Meaning: Create a function with the parameters ..args, and body body-exp. (Don't evaluate any of these!) Then, associate placeholder with that function (just like the previous variant of define).
• The Law of cond
  Syntax:

  (cond [question-a answer-a]
        [question-b answer-b]
        ...
        [question-z answer-z])
  

  Meaning: Evaluate question-a. If it is true (or, the keyword else), then the value of the entire cond is what we get by evaluating the expression answer-a. If question-a evaluated to false, then the value of the entire cond is:

  (cond [question-b answer-b]
        ...
        [question-z answer-z])
  

  (Cf. Recurring on a list.) It is an error to have a cond with no question/answer pairs, or if question-a doesn't evaluate to a be boolean.
  Why special form?: Suppose we tried to have cond be a regular function, where we evaluate all questions and all answers, before even invoking cond. What would happen to the following code?:

  (define some-list ...)
  (cond [(empty? some-list)  0]
        [(cons?  some-list)  (first some-list)])
  
  
  (define n ...)
  (define sum ...)
  
  ; Find the average of "n" things adding to "sum":
  ;
  (cond [(zero? n)  'average-not-defined]
        [else       (/ sum n)])
  

• The Law of define-struct
  Syntax: (define-struct struct-name (field-1 .. field-n)), where the struct-name and each field-i are placeholders. As mentioned, this just causes Scheme to create the constructor make-struct-name, the selectors struct-name-field-1, .. struct-name-field-n, and the predicate struct-name?.
• The law of and, or
  Syntax: (and arg1 arg2). Meaning: Evaluate arg1 first. If it is false, return false. Otherwise, evaluate arg2, and return it. (Similarly for or, but replace false with true.) This is called "short-circuiting" -- returning an answer even before evaluating all their arguments.
  Why special form?: These look like regular functions; why aren't they?
  It's not enough to say that "it's faster". For instance, * could be specially written so that if its first argument is 0, then it returns 0 without evaluating further arguments. But that's not what is does.
  There is a fundamental reason to make and a special form: consider (and (symbol? a-fo) (symbol=? a-fo 'gnat)). If a-fo is not a symbol, what happens?
  Thus the designers of scheme only break the general paradigm of functions when its critical.