anchor.diff:  
   Note that OP is intended for simple functions. In particular nested
   uses of OP are not supported."
  -  ;; No `single' yet.
     (let ((counter 0)
           (vars '()))
  -    (labels ((placeholder? (x env)
  +    (labels ((var-lexical? (x env)
  +               (declare (ignorable x env))
  +               #+sbcl (sb-walker:var-lexical-p x env)
  +               #-sbcl nil)
  +             (free? (x env) (not (var-lexical? x env)))
  +             (placeholder? (x env)
                  (declare (ignorable env))
  -               #+sbcl (when (sb-walker:var-lexical-p x env)
  -                        (return-from placeholder? nil))
                  (and (symbolp x)
  -                    (string= x '_)))
  +                    (free? x env)
  +                    (string= x "_")))
                (numbered-placeholder? (x env)
                  (declare (ignorable env))
  -               #+sbcl (when (sb-walker:var-lexical-p x env)
  -                        (return-from numbered-placeholder? nil))
                  (and (symbolp x)
  +                    (free? x env)
                       (let ((x (string x)))
  +                      #+sbcl (declare (notinline every))
                         (and (>= (length x) 2)
                              (string= '_ x :end2 1)
                              (every #'digit-char-p (subseq x 1))))))
                (rest-placeholder? (x env)
                  (declare (ignorable env))
  -               #+sbcl (when (sb-walker:var-lexical-p x env)
  -                        (return-from rest-placeholder? nil))
                  (and (symbolp x)
  -                    (string= x '_*)))
  +                    (free? x env)
  +                    (string= x "_*")))
                (splice (y env)
                  (mapcar (lambda (x)
                            (if (rest-placeholder? x env)
  
positive.code:                    (loop repeat (- n counter) do (make-var))))
                 x)
               (make-spliced-call (f env)
                 (let ((fn (car f)))
                   (if (eql fn 'progn)
                       (make-spliced-call
                        `((lambda (&rest xs)
                            xs)
                          ,@(rest f))
                        env)
                       (let ((splice (splice (cdr f) env)))
                         `(multiple-value-call (function ,fn)
                            ,@splice)))))
               (walk-op (x env)
                 (declare (ignorable env))
                 #+sbcl
  
negative.code: (in-readtable :standard)
  
  ;; TODO Handle dotted lists.
  (defmacro op (&body body &environment outer-env)
    "GOO's simple macro for positional lambdas.
  
  An OP is like a lambda without an argument list. Within the body of the OP
  