Remove the value stored with the key from storage.
        If key is not supplied then all values for the module are removed.
491728
def storage_del(self, key=None):
        
        if not self._module:
            return
        self._storage_init()
        module_name = self._module.module_full_name
        return self._storage.storage_del(module_name, key=key)
1344444
def remove_item(self, val):
        
        return cache.lrem(self.key, json.dumps(val))
535401
def discard(self, value):
        ''''''
        return self.cache.remove((self.value_pickler.dumps(value),))
1047454
function remove(key) {
           if (!isReserved(key)) {
             if (typeof data[key] !== "undefined") {
               delete data[key];

               if (me.device.localStorage === true) {
                 localStorage.removeItem("me.save." + key);
                 localStorage.setItem("me.save", JSON.stringify(Object.keys(data)));
               }
             }
           }
         }
1355522
def uncache(self, key, value):
        
        try:
            assert self.get(key) is value
            del self.data[key]
        except KeyError:
            # If the entry has already been removed from the cache, this will
            # result in KeyError which we ignore. If the entry is still in the
            # cache, but the weakref has been broken, this will result in
            # CacheFault (a KeyError subclass) which we also ignore. See the
            # comment in get() for an explanation of why this might happen.
            pass
864937
def unset(self, key):
        
        params = {
            'key': key
        }
        return self.client.delete(self._url(), params=params)
1188135
def delete(key, options = {})
      return super if options.include?(:raw)
      value, expires = super
      value if !expires || Time.now <= Time.at(expires)
    end
240482
def remove(self, value, _sa_initiator=None):
        """"""

        key = self.keyfunc(value)
        # Let self[key] raise if key is not in this collection
        # testlib.pragma exempt:__ne__
        if not self.__contains__(key) or value not in self[key]:
            raise sa_exc.InvalidRequestError(
                "Can not remove '%s': collection holds '%s' for key '%s'. "
                "Possible cause: is the MappedCollection key function "
                "based on mutable properties or properties that only obtain "
                "values after flush?" %
                (value, self[key], key))
        self.__getitem__(key, _sa_initiator).remove(value)
1207169
def pop(key, default=None):
    '''
    
    '''
    store = load()
    val = store.pop(key, default)
    dump(store)
    return val
928543
def remove(self, key):
        
        self.raise_error_if_not_open()

        if key in self._file:
            del self._file[key]
870358
def forget(self, key):
        
        path = self._path(key)

        if os.path.exists(path):
            os.remove(path)

            return True

        return False
1122632
public function clear()
    {
        if ($this->storageAdapter->has($this->key)) {
            $this->storageAdapter->remove($this->key);
        }
    }
15533
def discard(self, key):
        
        if key in self:
            i = self.map[key]
            del self.items[i]
            del self.map[key]
            for k, v in self.map.items():
                if v >= i:
                    self.map[k] = v - 1
1001484
def remove_column(self, key):
        
        if isinstance(key, int):
            index = key
            key = self.row_columns[key]
        else:
            index = self._column_index[key]
        for row in self.table:
            row.pop(index)
        self.row_columns = self.row_columns[:index] + self.row_columns[
                                                      index + 1:]
        self.pop_column(key)
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]
1214948
def delete(self, key):
    '''
    '''
    self.cache_datastore.delete(key)
    self.child_datastore.delete(key)
151970
def unset(self, key):
        
        self.cursor.execute('delete from kv where key=?', [key])
        if self.revision and self.cursor.rowcount:
            self.cursor.execute(
                'insert into kv_revisions values (?, ?, ?)',
                [key, self.revision, json.dumps('DELETED')])