anchor.diff:                `(declare (ignore ,@ignore-bindings)))
              ,@body)))))
   
  -(defmacro %alet* (bindings &body body)
  +(defmacro alet* (bindings &body body)
     "Asynchronous let*. Allows calculating a number of values in sequence via
      futures, and run the body when all values have computed with the bindings
      given available to the body.
  
positive.code:          (declare (ignore ,ignore-var))
           ,@body))))
  
  ;; -----------------------------------------------------------------------------
  ;; define the public interfaces for our heroic syntax macros
  ;; -----------------------------------------------------------------------------
  (defmacro alet (bindings &body body)
    "Asynchronous let. Allows calculating a number of values in parallel via
     futures, and runs the body when all values have computed with the bindings
     given available to the body.
     
     Also returns a future that fires with the values returned from the body form,
     which allows arbitrary nesting to get a final value(s)."
    `(%alet ,bindings ,@body))
  
  (defmacro alet* (bindings &body body)
    "Asynchronous let*. Allows calculating a number of values in sequence via
     futures, and run the body when all values have computed with the bindings
     given available to the body.
     
     Also returns a future that fires with the values returned from the body form,
     which allows arbitrary nesting to get a final value(s)."
    `(%alet ,bindings ,@body))
  
  (defmacro multiple-future-bind ((&rest bindings) future-gen &body body)
    "Like multiple-value-bind, but instead of a form that evaluates to multiple
     values, takes a form that generates a future."
    `(%multiple-future-bind ,bindings ,future-gen ,@body))
  
  (defmacro wait-for (future-gen &body body)
    "Wait for a future to finish, ignoring any values it returns. Can be useful
     when you want to run an async action but don't care about the return value
     (or it doesn't return a value) and you want to continue processing when it
     returns."
    `(%wait-for ,future-gen ,@body))
  
  (defmacro future-handler-case (body-form &rest error-forms)
    "Wrap all of our lovely syntax macros up with an event handler. This is more
     or less restricted to the form it's run in."
    (let ((event-handler (gensym "errhandler")))
      `(let ((,event-handler (lambda (ev)
                               (handler-case (error ev)
                                 ,@error-forms))))
         (handler-case
           (macrolet ((wrap-event-handler (future-gen handler)
                        (let ((vals (gensym "future-vals")))
                          `(let ((,vals (multiple-value-list ,future-gen)))
                             (if (futurep (car ,vals))
                                 (attach-errback (car ,vals) ,handler)
                                 (apply #'values ,vals))))))
             (macrolet ((alet (bindings &body body)
                          `(%alet ,(loop for (bind form) in bindings
                                         collect `(,bind (wrap-event-handler ,form ,',event-handler)))
                             ,@body))
                        (alet* (bindings &body body)
                          `(%alet* ,(loop for (bind form) in bindings
                                          collect `(,bind (wrap-event-handler ,form ,',event-handler)))
                             ,@body))
                        (multiple-future-bind ((&rest bindings) future-gen &body body)
                          `(%multiple-future-bind ,bindings
                               (wrap-event-handler ,future-gen ,',event-handler)
                             ,@body))
                        (wait-for (future-gen &body body)
                          `(%wait-for (wrap-event-handler ,future-gen ,',event-handler)
                             ,@body)))
               ,body-form))
           ,@error-forms))))
  
  
negative.code:                (alet* ,(cdr bindings) ,@body)))))
        `(progn ,@body)))
  
  (defmacro multiple-future-bind ((&rest bindings) future-gen &body body)
    "Like multiple-value-bind, but instead of a form that evaluates to multiple
     values, takes a form that generates a future."
    (let ((args (gensym "args")))
  