delete the key-value pair with the given key rooted at h
544783
private RedBlackTreeNode<Key, Value> delete(RedBlackTreeNode<Key, Value> h, Key key) {
	// assert get(h, key) != null;

	if (key.compareTo(h.getKey()) < 0) {
	    if (!isRed(h.getLeft()) && !isRed(h.getLeft().getLeft()))
		h = moveRedLeft(h);
	    h.setLeft(delete(h.getLeft(), key));
	} else {
	    if (isRed(h.getLeft()))
		h = rotateRight(h);
	    if (key.compareTo(h.getKey()) == 0 && (h.getRight() == null))
		return null;
	    if (!isRed(h.getRight()) && !isRed(h.getRight().getLeft()))
		h = moveRedRight(h);
	    if (key.compareTo(h.getKey()) == 0) {
		RedBlackTreeNode<Key, Value> x = min(h.getRight());
		h.setKey(x.getKey());
		h.setValue(x.getValue());
		// h.val = get(h.right, min(h.right).key);
		// h.key = min(h.right).key;
		h.setRight(deleteMin(h.getRight()));
	    } else
		h.setRight(delete(h.getRight(), key));
	}
	return balance(h);
    }
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)
674978
def delete(self, key):
        """"""
        if self.servers:
            key = self._qualified_key(key)
            hashed_key = self.key_hasher(key)
            self.client.delete(hashed_key)
1160178
def delete(key)
      key = key.key if key.respond_to?(:key)

      unless (idx = @indicies[key]).nil?
        @indicies.delete(key)
        @indicies.each { |k,v| @indicies[k] = v -= 1 if v > idx }
        @lines.delete_at(idx)
      end
    end
753414
def del_key(self, k):
        """"""
        if k not in self.mirror:
            raise KeyError
        del self.proxy[k]
        if '_config' in self.proxy and k in self.proxy['_config']:
            del self.proxy['_config'][k]
1026512
def delete(self, row):
        """"""
        i = self._get_key_index(row)
        del self.keys[i]
857693
private void removeKey(Key k, List<Key>[] vector) {
    if (k == null) {
      throw new NullPointerException("Key can not be null");
    }
    if (vector == null) {
      throw new NullPointerException("ArrayList<Key>[] can not be null");
    }

    int[] h = hash.hash(k);
    hash.clear();

    for (int i = 0; i < nbHash; i++) {
      vector[h[i]].remove(k);
    }
  }
1163087
def delete(*keys, **connection_args):
    '''
    
    '''
    # Get connection args from keywords if set
    conn_args = {}
    for arg in ['host', 'port', 'db', 'password']:
        if arg in connection_args:
            conn_args[arg] = connection_args[arg]

    server = _connect(**conn_args)
    return server.delete(*keys)
253670
public T remove(final int key) {

        final int hash  = hashOf(key);
        int index = hash & mask;
        if (containsKey(key, index)) {
            return doRemove(index);
        }

        if (states[index] == FREE) {
            return missingEntries;
        }

        int j = index;
        for (int perturb = perturb(hash); states[index] != FREE; perturb >>= PERTURB_SHIFT) {
            j = probe(perturb, j);
            index = j & mask;
            if (containsKey(key, index)) {
                return doRemove(index);
            }
        }

        return missingEntries;

    }
1143689
public static void raw_remove(Key key) {
    Value v = STORE.remove(key);
    if( v != null ) v.removePersist();
  }
376836
def delete(self, key):
    '''
    '''
    try:
      del self._collection(key)[key]

      if len(self._collection(key)) == 0:
        del self._items[str(key.path)]
    except KeyError, e:
      pass
635742
def unset_value(self, key):
        # type: (str) -> None
        
        self._ensure_have_load_only()

        if key not in self._config[self.load_only]:
            raise ConfigurationError("No such key - {}".format(key))

        fname, parser = self._get_parser_to_modify()

        if parser is not None:
            section, name = _disassemble_key(key)

            # Remove the key in the parser
            modified_something = False
            if parser.has_section(section):
                # Returns whether the option was removed or not
                modified_something = parser.remove_option(section, name)

            if modified_something:
                # name removed from parser, section may now be empty
                section_iter = iter(parser.items(section))
                try:
                    val = six.next(section_iter)
                except StopIteration:
                    val = None

                if val is None:
                    parser.remove_section(section)

                self._mark_as_modified(fname, parser)
            else:
                raise ConfigurationError(
                    "Fatal Internal error [id=1]. Please report as a bug."
                )

        del self._config[self.load_only][key]
243373
def delete( key )
        v = super( key )
        if String === v
            v = YAML.load( v )
        end
        v
    end
493402
def _pop(self, key, default=None):
        
        value = default
        if key in self:
            value = self[key]
            del self[key]
        return value
292767
protected void setHeaderOutImpl(String key, String value)
  {
    int i = 0;
    boolean hasHeader = false;
    
    ArrayList<String> keys = _headerKeysOut;
    ArrayList<String> values = _headerValuesOut;

    for (i = keys.size() - 1; i >= 0; i--) {
      String oldKey = keys.get(i);

      if (oldKey.equalsIgnoreCase(key)) {
        if (hasHeader) {
          keys.remove(i);
          values.remove(i);
        }
        else {
          hasHeader = true;

          values.set(i, value);
        }
      }
    }

    if (! hasHeader) {
      keys.add(key);
      values.add(value);
    }
  }
1362434
def remove(self, key, glob=False):
        """"""
        ns = self.namespace(key, glob)
        try:
            self.keyring.delete_password(ns, key)
        except PasswordDeleteError:  # OSX and gnome have no delete method 
            self.set(key, '', glob)
21486
def remove(self, key):
        ''''''
        copydict = ImmutableDict()
        copydict.tree = self.tree.remove(hash(key))
        copydict._length = self._length - 1
        return copydict