anchor.diff:    (catch 'run-once
       (bind-run-state ((result-list '()))
         (let ((values (mapcar #'funcall generators)))
  -        (apply body values)
  +        (funcall body values)
           (cond
             ((null result-list)
              (throw 'run-once (list :no-tests)))
  
positive.code: ;;;; We provide a set of built-in generators.
  
  (defun gen-integer (&key (max (1+ most-positive-fixnum))
                      (min (1- most-negative-fixnum)))
    "Returns a generator which produces random integers greater
  than or equal to MIN and less than or equal to MIN."
    (lambda ()
  
negative.code: returning true. This second run limit prevents that.")
  
  (defmacro for-all (bindings &body body)
    "Bind BINDINGS to random variables and test BODY *num-trials* times.
  
  BINDINGS is a list of binding forms, each element is a list
  of (BINDING VALUE &optional GUARD). Value, which is evaluated
  once when the for-all is evaluated, must return a generator which
  be called each time BODY is evaluated. BINDING is either a symbol
  or a list which will be passed to destructuring-bind. GUARD is a
  form which, if present, stops BODY from executing when IT returns
  NIL. The GUARDS are evaluated after all the random data has been
  generated and they can refer to the current value of any
  binding. NB: Generator forms, unlike guard forms, can not contain
  references to the boud variables.
  
  Examples:
  
    (for-all ((a (gen-integer)))
      (is (integerp a)))
  
    (for-all ((a (gen-integer) (plusp a)))
      (is (integerp a))
      (is (plusp a)))
  
    (for-all ((less (gen-integer))
              (more (gen-integer) (< less more)))
      (is (<= less more)))
  
    (for-all (((a b) (gen-two-integers)))
      (is (integerp a))
      (is (integerp b)))"
    (with-unique-names (test-lambda-args)
      `(perform-random-testing
        (list ,@(mapcar #'second bindings))
        (lambda (,test-lambda-args)
          (destructuring-bind ,(mapcar #'first bindings)
              ,test-lambda-args
            (if (and ,@(delete-if #'null (mapcar #'third bindings)))
                (progn ,@body)
                (throw 'run-once
                  (list :guard-conditions-failed))))))))
  
  ;;;; *** Implementation 
  
  ;;;; We could just make FOR-ALL a monster macro, but having FOR-ALL be
  ;;;; a preproccessor for the perform-random-testing function is
  ;;;; actually much easier.
  
  (defun perform-random-testing (generators body)
    (loop
  