// Del deletes the key and its associated value
180791
func (hm *SyncedHashMap) Del(key Hashable) {
	hm.Lock()
	defer hm.Unlock()
	delete((*hm).keys, key.Hash())
	delete((*hm).values, key.Hash())
}
459882
func (kv *KV) Delete(key []byte) error {
	return kv.db.Update(func(txn *badger.Txn) error {
		return txn.Delete(key)
	})
}
603398
func (c Claims) Del(key string) {
	jwt.Claims(c).Del(key)
}
746330
func Del(id string, params *stripe.EphemeralKeyParams) (*stripe.EphemeralKey, error) {
	return getC().Del(id, params)
}
832374
func (tx *txn) Delete(key string) keyval.BytesTxn {
	tx.ops = append(tx.ops, &api.KVTxnOp{
		Verb: api.KVDelete,
		Key:  key,
	})
	return tx
}
1207533
func (m *lockingMap) Delete(key string) {
	m.keyLocker.Lock(key)
	defer m.keyLocker.Unlock(key)

	m.lock.Lock()
	defer m.lock.Unlock()

	delete(m.data, key)
}
828742
func (rc *Memcache) Del(key string) error {
	err := rc.c.Delete(Md5(key))
	if err != nil {
		if rc.Debug {
			log.Println("[Memcache]DelErr: ", err, "Key:", key)
		}
		return err
	}
	if rc.Debug {
		log.Println("[Memcache]Del: ", key)
	}
	return err
}
52230
func (om *OrdMap) Delete(key interface{}) {
	rkey := ty.AssertType(key, om.ktype)

	// Avoid doing work if we don't need to.
	if !om.exists(rkey) {
		return
	}

	keysLen := om.keys.Len()
	for i := 0; i < keysLen; i++ {
		if key == om.keys.Index(i).Interface() {
			// om.keys = append(om.keys[:i], om.keys[i+1:]...)
			om.keys = reflect.AppendSlice(
				om.keys.Slice(0, i), om.keys.Slice(i+1, keysLen))
			break
		}
	}

	// Setting a key to a zero reflect.Value deletes the key from the map.
	om.m.SetMapIndex(rkey, reflect.Value{})
}
287194
func (c *Cache) Delete(key string) {
	c.Client.Delete(cacheKey(key))
}
316299
func (m *Miniredis) Del(k string) bool {
	return m.DB(m.selectedDB).Del(k)
}
330905
func (c *RedisCacher) Delete(key string) error {
	key = c.prefix + key
	if err := c.c.Del(key).Err(); err != nil {
		return err
	}

	if c.occupyMode {
		return nil
	}
	return c.c.HDel(c.hsetName, key).Err()
}
229207
func (b *Bucket) Del(ctx context.Context, path string) error {
	req := &request{
		method: "DELETE",
		bucket: b.Name,
		path:   path,
	}
	return b.S3.query(ctx, req, nil)
}
1046541
func (rc *Redis) Del(key string) error {
	var err error
	if _, err = rc.do("DEL", key); err != nil {
		return err
	}
	_, err = rc.do("HDEL", rc.key, key)
	if err != nil {
		if rc.Debug {
			log.Println("[Redis]DelErr: ", err, "Key:", key)
		}
		return err
	}
	if rc.Debug {
		log.Println("[Redis]Del: ", key)
	}
	return err
}
1082875
func (c *cookies) Del(key string) {
	c.Expire(key, time.Date(1900, 1, 1, 0, 0, 0, 0, time.Local))
}
764827
func (db *RedisDB) Del(k string) bool {
	db.master.Lock()
	defer db.master.Unlock()
	if !db.exists(k) {
		return false
	}
	db.del(k, true)
	return true
}
819
func (ini *INI) Del(section, key string) bool {
	// Remove the section.
	if key == "" {
		if section == "" {
			ini.global = iniSection{}
			return true
		}

		return ini.rmSection(section)
	}

	// Remove the key for the section.
	return ini.getSection(section).rmItem(key, ini.isCaseSensitive)
}
926077
func (rs *Set) Del(value string) error {
	conn := rs.pool.Get(rs.dbindex)
	_, err := conn.Do("SREM", rs.id, value)
	return err
}