Add a errback without an associated callback.
180621
def add_errback(self, errback, *errback_args, **errback_kwargs):
        """"""
        return self.add_callbacks(None, errback=errback, errback_args=errback_args,
                           errback_kwargs=errback_kwargs)
69010
def add_callback(self, callback, *callback_args, **callback_kwargs):
        """"""
        return self.add_callbacks(callback, callback_args=callback_args,
                           callback_kwargs=callback_kwargs)
1112104
function (def, err) {
    def.errors = def.errors || []
    err.message = err.message.cyan
    def.errors.push(err)
  }
887124
def __safe_errback(self, room_data, err_condition, err_text):
        
        method = room_data.errback
        if method is not None:
            try:
                method(room_data.room, room_data.nick, err_condition, err_text)
            except Exception as ex:
                self.__logger.exception("Error calling back room creator: %s",
                                        ex)
637045
function AddError(message,nopush) {
  if (displayErrors) console.error(message);
  if (!nopush) errors.push(message);
}
1315469
def on_error(self, ex):
        
        if self._d:
            self._d.errback()
            self._d = None
1224169
function failWrapper(msg, mode) {
  gT.l.fail(msg);
  if (mode && mode.accName) {
    mode.accName = false; // eslint-disable-line no-param-reassign
  }
}
856212
def add_callback(self, fn, *args, **kwargs):
        """"""
        if _debug: IOCB._debug("add_callback(%d) %r %r %r", self.ioID, fn, args, kwargs)

        # store it
        self.ioCallback.append((fn, args, kwargs))

        # already complete?
        if self.ioComplete.isSet():
            self.trigger()
342156
def error(request, message, extra_tags='', fail_silently=False):
    """"""
    add_message(request, constants.ERROR, message, extra_tags=extra_tags,
                fail_silently=fail_silently)
1209062
def add_error(key, error, message = nil)
      if error.is_a? Symbol
        error = ErrorAtom.new(key, error, message: message)
      elsif error.is_a?(Mutations::ErrorAtom) || error.is_a?(Mutations::ErrorArray) || error.is_a?(Mutations::ErrorHash)

      else
        raise ArgumentError.new("Invalid error of kind #{error.class}")
      end

      @errors ||= ErrorHash.new
      @errors.tap do |errs|
        path = key.to_s.split(".")
        last = path.pop
        inner = path.inject(errs) do |cur_errors,part|
          cur_errors[part.to_sym] ||= ErrorHash.new
        end
        inner[last] = error
      end
    end
186482
function add(err, req, res) {
  if(err) {
    // TODO: send args length errors

    // transaction errors are not queued
    // but the transaction is left open for more
    // command to be queued
    if(err instanceof TransactionError) {
      return res.send(err);
    }
    // last error
    this.error = err;
  }

  this.queue.push({err: err, req: req, res: res});
  res.send(null, QUEUED);
}
693709
def add_ignore(self, depend):
        """"""
        try:
            self._add_child(self.ignore, self.ignore_set, depend)
        except TypeError as e:
            e = e.args[0]
            if SCons.Util.is_List(e):
                s = list(map(str, e))
            else:
                s = str(e)
            raise SCons.Errors.UserError("attempted to ignore a non-Node dependency of %s:\n\t%s is a %s, not a Node" % (str(self), s, type(e)))
849686
def _add_none_handler(validation_callable,  # type: Callable
                      none_policy           # type: int
                      ):
    # type: (...) -> Callable
    
    if none_policy is NonePolicy.SKIP:
        return _none_accepter(validation_callable)  # accept all None values

    elif none_policy is NonePolicy.FAIL:
        return _none_rejecter(validation_callable)  # reject all None values

    elif none_policy is NonePolicy.VALIDATE:
        return validation_callable                  # do not handle None specifically, do not wrap

    else:
        raise ValueError('Invalid none_policy : ' + str(none_policy))
1159911
def _add_err(self, exinfo):
        
        if self._err:
            return
        self._err = exinfo
        self.all_ok = False
468246
def add(self, callback_type, callback):
        """"""

        with self.lock:
            self.callbacks[callback_type].append(callback)
140575
function KboxRequireError(id, err) {
  Error.call(this);
  this.message = [id, err.message].join(' -> ');
  this.stack = [this.message, err.stack].join('\n');
}
1275249
def add_codes(err_cls):
    """"""
    class ErrorsWithCodes(object):
        def __getattribute__(self, code):
            msg = getattr(err_cls, code)
            return '[{code}] {msg}'.format(code=code, msg=msg)
    return ErrorsWithCodes()