Delete the ActionErrors with the specified keys.

@param  string[] ...$keys - zero or more error keys to delete; without a key all ActionErrors are deleted

@return array - the deleted ActionErrors
429370
public function removeActionErrors(...$keys) {
        $errors = $this->getAttribute(ACTION_ERRORS_KEY);
        $dropped = [];

        foreach ($keys as $key) {
            if (isset($errors[$key]))
                $dropped[$key] = $errors[$key];
            unset($this->attributes[ACTION_ERRORS_KEY][$key]);
        }
        if ($keys)
            return $dropped;

        unset($this->attributes[ACTION_ERRORS_KEY]);
        return $errors;
    }
824148
public function replaceAllKeys(array $keys): self
    {
        return static::create(
            \array_combine($keys, $this->getArray()),
            $this->iteratorClass,
            false
        );
    }
1262787
public function unsetItems($keys = null)
    {
        if (is_null($keys)) {
            $this->_items = [];
        } elseif (is_scalar($keys)) {
            unset($this->_items[$keys]);
        } else {
            foreach ($keys as $k) {
                unset($this->_items[$k]);
            }
        }
    }
1121750
public function reduce(...$keys)
    {
        $keys = $this->normalizeKeys($keys);

        foreach ($this->keys() as $key) {
            if (!in_array($key, $keys, true)) {
                $this->remove($key);
            }
        }

        return $this;
    }
703779
public function del($key) {

        $keys = func_get_args();
        $removed = 0;

        foreach ($keys as $key) {
            $sql = 'DELETE FROM '.$this->table.' WHERE `key`="'.$key.'"';
            $this->connection->exec($sql);
            $removed++;
        }

        return $removed;
    }
680972
public function delete_many(array $keys) {
        if ($this->clustered) {
            // Get the minimum deleted from any of the connections.
            $count = count($keys);
            foreach ($this->setconnections as $connection) {
                $count = min($this->delete_many_connection($connection, $keys), $count);
            }
            return $count;
        }

        return $this->delete_many_connection($this->connection, $keys);
    }
1087678
public function replaceKeys(array $keys): self
    {
        $values = \array_values($this->getArray());
        $result = \array_combine($keys, $values);

        return static::create(
            $result,
            $this->iteratorClass,
            false
        );
    }
1049708
public function deleteItems(array $keys): bool
    {
        foreach ($keys as $key) {
            $this->delete($key);
        }

        return true;
    }
155179
public function reflash(array $keys = array())
    {
        $data = empty($keys) ? $this->session : array_intersect_key($this->session, array_flip($keys));
        return $this->clear($data);
    }
1144839
public function deleteIndex($keys)
    {
        if (is_string($keys)) {
            $indexName = $keys;
            if (! preg_match('#_-?1$#', $indexName)) {
                $indexName .= '_1';
            }
        } elseif (is_array($keys)) {
            $indexName = \MongoDB\generate_index_name($keys);
        } else {
            throw new \InvalidArgumentException();
        }

        try {
            return TypeConverter::toLegacy($this->collection->dropIndex($indexName));
        } catch (\MongoDB\Driver\Exception\Exception $e) {
            return ExceptionConverter::toResultArray($e) + ['nIndexesWas' => count($this->getIndexInfo())];
        }
    }
1285468
public function deleteMultiple( $keys )
	{
		foreach( $keys as $key ) {
			$this->object->remove( $this->prefix . $key );
		}
	}
97135
public function delete(array $keys) {
		foreach ($keys as $key) {
			if (!isset($this->_cache[$key])) {
				return false;
			}
			unset($this->_cache[$key]);
		}
		return true;
	}
58444
public function keysExist(array $keys)
    {
        foreach ($keys as $key) {
            if (!$this->keyExists($key)) {
                return false;
            }
        }
        return true;
    }
325748
public function delete(/*# string */ $key)/*# : bool */
    {
        $ends = [ $this->front, $this->back ];
        foreach ($ends as $end) {
            if (!$end->delete($key)) {
                return $this->falseAndSetError(
                    $end->getError(),
                    $end->getErrorCode()
                );
            }
        }
        return $this->trueAndFlushError();
    }
383403
public function delete($keys)
    {
        $keys = (array) $keys;

        foreach ($keys as $key) {
            if ($this->exists($this->items, $key)) {
                unset($this->items[$key]);

                continue;
            }

            $items = &$this->items;
            $segments = explode('.', $key);
            $lastSegment = array_pop($segments);

            foreach ($segments as $segment) {
                if (!isset($items[$segment]) || !is_array($items[$segment])) {
                    continue 2;
                }

                $items = &$items[$segment];
            }

            unset($items[$lastSegment]);
        }
    }
1187477
public function delete_many(array $keys) {
        // The number of items that have actually being removed.
        $reduction = 0;
        foreach ($keys as $key) {
            if (isset($this->store[$key])) {
                $reduction++;
            }
            unset($this->store[$key]);
        }
        if ($this->maxsize !== false) {
            $this->storecount -= $reduction;
        }
        return $reduction;
    }
456694
public function forgetMany(array $keys)
    {
        if (! method_exists($this->store, 'forgetMany')) {
            return array_combine($keys, array_map([$this, 'forget'], $keys));
        }

        return $this->store->forgetMany($this->tagKeys($keys));
    }