anchor.diff:           (bind :on-failure form 
                  :binding-mode multiple 
                  (lhs '-> rhs) form `(lambda (,@lhs) ,@rhs)))))
  +
  +(add-transform underscore-lambda
  +   (walking-hook
  +      (lambda (form)
  +         (bind :on-failure form 
  +               :binding-mode multiple 
  +               (fun '_ (optional rest)) form (generate-hole-lambda '_ form)))))
  +
  +(add-transform hole-lambda
  +   (walking-hook
  +      (lambda (form)
  +         (bind :on-failure form 
  +               :binding-mode multiple 
  +               (fun '<> (optional rest)) form (generate-hole-lambda '<> form)))))
  +
  +(defun generate-hole-lambda (symbol form)
  +   (iter (for src in form)
  +         (collect 
  +            (if (symbol-eq symbol src)
  +                (let ((gs (gen-sym "lambda-arg")))
  +                      (collect gs into vars)
  +                      gs)
  +                src)
  +            into body)
  +         (finally (return `(lambda (,@vars) ,body)))))
  
positive.code: (ql:quickload '(alexandria anaphora iterate destructuring-match provide-toplevel) :silent t)
  
  (defpackage transforms
    (:export enable-transforms)
    (:use cl iterate anaphora destructuring-match provide-toplevel))
  
  (in-package transforms)
  
  (defparameter *transforms* nil)
  
  (defun symbol-eq (x y)
     (and (symbolp x) (symbolp y) (string= (string x) (string y))))
  
negative.code:                   (funcall it)
                    (error "unknown transform ~a" form)))))
  
  (defun transform (form)
     (provide-toplevel::apply-hooks form))
  
  (defun walking-hook (lam)
     (lambda ()
        (add-hook (lambda (form)
  