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 define is a special form: What if we tried this as a normal function, which evaluates all its arguments first?

  • 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 is condspecial 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)])
  
  
  
  ;;;;; Or, consider:
  
  (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.