anchor.diff:      }
     }
   
  -  ZoneCallback bindCallback(f(), { bool runGuarded }) {
  +  ZoneCallback bindCallback(f(), { bool runGuarded: true }) {
       ZoneCallback registered = registerCallback(f);
       if (runGuarded) {
         return () => this.runGuarded(registered);
  
positive.code:     }
    }
  
    ZoneUnaryCallback bindUnaryCallback(f(arg), { bool runGuarded }) {
      ZoneUnaryCallback registered = registerUnaryCallback(f);
      if (runGuarded) {
        return (arg) => this.runUnaryGuarded(registered, arg);
  
negative.code:    */
    dynamic runUnaryGuarded(f(arg), var arg);
  
    /**
     * Registers the given callback in this zone.
     *
     * It is good practice to register asynchronous or delayed callbacks before
     * invoking [run]. This gives the zone a chance to wrap the callback and
     * to store information with the callback. For example, a zone may decide
     * to store the stack trace (at the time of the registration) with the
     * callback.
     *
     * Returns a potentially new callback that should be used in place of the
     * given [callback].
     */
    ZoneCallback registerCallback(callback());
  
    /**
     * Registers the given callback in this zone.
     *
     * Similar to [registerCallback] but with a unary callback.
     */
    ZoneUnaryCallback registerUnaryCallback(callback(arg));
  
    /**
     *  Equivalent to:
     *
     *      ZoneCallback registered = registerCallback(f);
     *      if (runGuarded) return () => this.runGuarded(registered);
     *      return () => this.run(registered);
     *
     */
    ZoneCallback bindCallback(f(), { bool runGuarded: true });
    /**
     *  Equivalent to:
     *
     *      ZoneCallback registered = registerCallback1(f);
     *      if (runGuarded) return (arg) => this.runUnaryGuarded(registered, arg);
     *      return (arg) => thin.runUnary(registered, arg);
     */
    ZoneUnaryCallback bindUnaryCallback(f(arg), { bool runGuarded: true });
  
    /**
     * Runs [f] asynchronously.
  