LISP PARTS I-V

apply[fn;a;a] =
     [atom[fn] -> [eq[fn;CAR] -> caar[x];
          eq[fn;CDR] -> cdar[x];
          eq[fn;CONS] -> cons[car[x];card[x]];
          eq[fn;ATOM] -> atom[car[x]];
          eq[fn;EQ] -> eq[car[x];cadr[x]];
          T -> apply[eval[fn;a];x;a]];
     eq[car[fn];LAMBDA] -> eval[caddr[fn];pairlis[card[fn];x;a]];
     eq[car[fn];LABEL] -> apply[caddr[fn];x;cons[cons[cadr[fn];
                        caddr[fn]];a]]]

eval[e;a] = [atom[e] - cdr[assoc[e;a]];
      atom[car[e]] ->
          [eq[car[e],QUOTE] -> cadr[e]];
          eq[car[e];COND] -> evcon[cdr[e];a];
          T-> apply[eval[fn;a];x;x]];
      T -> apply[car[e];evlis[cdr[e];a];a]]

(DEFINE (EVAL EXP ENV PROCEDURES)
  (COND ((ATOM EXP)
         (COND ((EQ EXP 'NIL) 'NIL)
               ((EQ EXP 'T) 'T)
               ((NUMBERP EXP) EXP)
               (T (VALUE EXP ENV))))
        ((EQ (CAR EXP) 'QUOTE)
         (CADR EXP))
        ((EQ (CAR EXP) 'COND)
         (EVCOND (CDR EXP) ENV PROCEDURES))
        (T (APPLY (VALUE (CAR EXP) PROCEDURES)
                  (EVLIS (CDR EXP) ENV PROCEDURES)
                  PROCEDURES))))

(DEFINE (APPLY FUN ARGS PROCEDURES)
  (COND ((PRIMOP FUN) (PRIMOP-APPLY FUN ARGS))
        (T (EVAL (CADR FUN)
                 (BIND (CAR FUN) ARGS '())
                 PROCEDURES))))

(DEFINE (EVCOND CLAUSES ENV PROCEDURES)
  (COND ((NULL CLAUSES) (ERROR))
        ((EVAL (CAAR CLAUSES) ENV PROCEDURES)
         (EVAL (CADAR CLAUSES) ENV PROCEDURES))
        (T (EVCOND (CDR CLAUSES) ENV PROCEDURES))))

(DEFINE (EVLIS ARGLIST ENV PROCEDURES)
  (COND ((NULL ARGLIST) '())
        (T (CONS (EVAL (CAR ARGLIST) ENV PROCEDURES)
                 (EVLIS (CDR ARGLIST) ENV PROCEDURES)))))

M-expressions considered gay as hell.

>>3
That's why they were converted to S-expressions. Sadly, S-expressions are too wimpy for real work, and bitC has dropped them in favor of 'block syntax'.

>>4
using bitC to attempt to win an argument
I lol'd

>>5
Huh? What argument?