Remove a single stashed state from the stash list.
When no $stash is given, it removes the latest one.

@param int|null $stash Takes the stash number.

@return mixed
965525
public function drop($stash = null)
    {
        $this->arguments[] = 'show';
        if ($stash) {
            $this->arguments[] = 'stash@{' . $stash . '}';
        }
        return $this->run();
    }
815394
public function remove($key)
    {
        if (!$this->containsKey($key)) {
            return null;
        }

        $item = $this->items[$key];
        unset($this->items[$key]);

        return $item;
    }
298589
public function delete($key = null)
    {
        if ($key === null) {
            $this->reset();

            return $this;
        }

        $arr = &$this->getStackByReference($key);

        if (is_array($arr) && array_key_exists($key, $arr)) {
            unset($arr[$key]);
        }

        return $this;
    }
1103445
public function remove($sKey)
    {
        if ($this->contains($sKey)) {
            $mRes = $_SESSION[$sKey];
            unset($_SESSION[$sKey]);
            return $mRes;
        } else {
            return null;
        }
    }
420527
public function stashBranch(string $branch, string $stash)
    {
        $stashCommand = StashCommand::getInstance($this);
        $command = $stashCommand->branch($branch, $stash);
        $this->caller->execute($command);
    }
427944
def unstash_it(self, sync=False):
        
        if self.stash_index is not None:
            return self.git_exec(
                ['stash', 'pop', 'stash@{{{0}}}'.format(self.stash_index)])
1015886
public function listStashes(array $options = null)
    {
        $this->clearAll();
        $this->addCommandName(self::STASH_COMMAND . ' list');
        if (null !== $options) {
            $this->addCommandSubject($options);
        }
        return $this->getCommand();
    }
525248
public function remove($key)
    {
        $value = null;

        if ($this->has($key)) {
            $value = $this->data[$key];
            unset($this->data[$key]);
        }

        return $value;
    }
752666
function removeThis( $id, $currentVersion = null )
    {
        $dataType = $this->dataType();
        if ( !$dataType )
            return false;
        $dataType->deleteStoredObjectAttribute( $this, $currentVersion );
        if( $currentVersion == null )
        {
            eZPersistentObject::removeObject( eZContentObjectAttribute::definition(),
                                              array( "id" => $id ) );
        }
        else
        {
            eZPersistentObject::removeObject( eZContentObjectAttribute::definition(),
                                              array( "id" => $id,
                                                     "version" => $currentVersion ) );
        }
    }
1234344
public function pop()
    {
        if (null !== $this->getDraft()) {
            return $this->getDraft()->pop();
        }

        $last = $this->last();

        if (null === $last) {
            return;
        }

        array_pop($this->_data);
        $content = null;
        if (isset($this->subcontentmap[$last->getUid()])) {
            $content = $this->_subcontent->get($this->subcontentmap[$last->getUid()]);
            $this->_subcontent->removeElement($content);
            unset($this->subcontentmap[$last->getUid()]);
        }

        $this->rewind();

        return $content;
    }
1038729
public function remove( $item )
	{
		$index	= $this->getIndex( $item );
		unset( $this->list[$index] );
		return $this->write();
	}
1025304
public function pop()
    {
        if ($this->count() == 0) {
            return null;
        }
        $ret = $this->getLast();
        $lastKey = $this->getInternalIterator()->key();
        $this->offsetUnset((string) $lastKey);

        return $ret;
    }
382266
public function remove($offset) // -> mixed
	{
		$return = null;
		
		if($this->offsetExists($offset))
		{
			if(0 === $offset)
			{
				$return = $this->shift();
			}
			else
			{
				$this->moveToOffset($offset - 1);
				
				$prev   = $this->worker;
				$pos    = $prev->next;
				$return = $pos->data;
				$last   = $offset === $this->size - 1;
				
				if($last)
				{
					$prev->next = null;
					$this->last = $prev;
				}
				else
				{
					$prev->next = $pos->next;
				}
				
				unset($pos);
				
				--$this->size;
				
				if(null !== $this->current_key)
				{
					if($this->current_key === $offset)
					{
						$this->current = $prev->next;
					}
					else if($this->current_key > $offset)
					{
						--$this->current_key;
					}
				}
			}
		}
		else
		{
			throw new OutOfRangeException('Offset invalid or out of range');
		}
		
		return $return;
	}
1045056
public function removeEmpty(): Utility
    {
        $filteredBag = array_filter($this->bag, function ($value) {
            return !empty($value);
        });

        if (!$this->isAssociative()) {
            $filteredBag = array_values($filteredBag);
        }

        return new static($filteredBag);
    }
381381
public function forget($keys = null)
    {
        if (is_null($keys)) {
            $this->items = [];
            return $this;
        }

        foreach ((array)$keys as $key) {
            unset($this->items[$key]);
        }

        return $this;
    }
805842
public function clearSort($key=null)
    {
        if (!$key) {
            $this->sorting = [];
            return $this;
        }

        $this->bootCanSortMethodsOnce();

        if (isset($this->sorting[$key])) {
            unset($this->sorting[$key]);
        }

        return $this;
    }
759793
public function delete($current)
	{
		if (is_string($current)) {
			return $this->deleteCurrentFiles($current);
		}

		$toDelete = $this->deleting()->keys()->all();

		$this->deleteCurrentFiles(
			$current->whereIn('id', $toDelete)
		);

		return $toDelete;
	}