Move the internal pointer backward
And get the previous element in the collection

@return mixed
359737
public function getPrevious()
    {
        if ($this->isFirst()) {
            return null;
        }

        $this->seek($this->getPosition() - 1);

        return $this->current();
    }
765580
public function previous()
    {
        $this->pointerAtEnd = false;
        $this->pointerAtStart = prev($this->stream) === false;
    }
190577
private function PreviousItem()
    {
        $this->previous = $this->GetTreeItem('previous');
        return $this->previous->Exists() ? $this->previous : null;
    }
160791
public function previous()
    {
        $this->_itemValid = true;

        if (!prev($this->_items)) {
            $this->_itemValid = false;
        } else {
            $this->_itemPosition--;
        }
    }
1225845
public function pop_back()
    {
        if ($this->count() <= 0) {
            throw new \OutOfBoundsException();
        }

        $item = $this->list[$this->count() - 1];

        $this->removeLast();

        return $item;
    }
650576
public function last()
    {
        $this->executeBeforeCallback();

        return count($this->items) > 0 ? end($this->items) : null;
    }
557610
public function getCurrent()
    {
        if (false === $this->pointer || empty($this->ids)) {
            return null;
        }
        return $this->ids[$this->pointer];
    }
118778
protected function _loop()
    {
        // Ensure that there are items on the stack
        if (!$this->_hasParents()) {
            return $this->_createIteration(null, null);
        }

        // Get current top item on the stack and its current iteration entry
        $parent  = &$this->_getCurrentIterable();
        $current = $this->_createCurrentIteration($parent);

        // Reached end of current iterable
        if ($current->getKey() === null) {
            return $this->_backtrackLoop();
        }

        // Element is a leaf
        if (!$this->_isElementHasChildren($current->getValue())) {
            next($parent);

            return $current;
        }

        // Element is not a leaf; push to stack
        $children = $current->getValue();
        $this->_pushParent($children);

        if ($this->_isMode(R::MODE_SELF_FIRST)) {
            return $current;
        }

        return $this->_loop();
    }
306482
public function getLastRow()
    {
        $rows = $this->data['rows'];
        if (empty($rows)) {
            return false;
        }

        $row = array_slice($rows, count($rows) - 1);

        return current($row);
    }
675693
public function prev()
    {
        $value = prev($this->_data);
        return key($this->_data) !== null ? $value : null;
    }
1337546
public function undo()
    {
        end($this->history);
        for ($i=0; $i<$this->history_offset; $i++) {
            prev($this->history);
        }
        $index = prev($this->history);
        if (!empty($index)) {
            $this->current_passage = $index;
            $this->history_offset++;
            $this->storyline = array_slice($this->storyline, 0, -1);
            return $this->getCurrentPassage();
        }
        return false;
    }
1063177
public function rear() {
        if (null === $this->queue) return null;
        if (!isset($this->queue[$this->head])) return null;
        return $this->queue[$this->head];
    }
1305395
public function moveToBottom()
    {
        if ($this->isNotInList()) return $this;

        $this->getConnection()->transaction(function() {

            $this->decrementPositionsOfItemsBelow();

            $bottomPosition = $this->getBottomPositionValue($this);
            $newPosition    = (null === $bottomPosition) ? $this->listifyTop() : $bottomPosition + 1;

            $this->setListPosition($newPosition);
        });

        return $this;
    }
151010
public function getPrev()
    {
        if ($this->getPage() != $this->getFirstPage()) {
            $prev = $this->getPage() - 1;
        } else {
            $prev = false;
        }

        return $prev;
    }
408016
public function getCurrentRow()
        {
            if (isset($this->rows[($this->int_ptr - 1)])) {
                return $this->rows[($this->int_ptr - 1)];
            }
            return null;
        }
112832
function reverse () {
    $rev = $this;
    	$rev->edits = array();
    	foreach ($this->edits as $edit) {
    		$rev->edits[] = $edit->reverse();
    	}
    return $rev;
    }
508155
protected function NextItem()
	{
		while (true)
		{
			if ( ! is_null( $this->childIter ) )
			{
				if ( $this->childIter instanceof ExprIterator )
				{
					$result = $this->childIter;
					$this->childIter = null;
					return $result;
				}
				else
				{
					if ( $this->childIter->MoveNext() )
						return $this->childIter->getCurrent();
					else
						$this->childIter = null;
				}
			}
			if ( ! $this->iter->MoveNext() )
				return null;

			if ( $this->owner->MoveNext( $this->provider, $this->dataPool, $this->iter->getCurrent(), $res ) )
			{
				if ( $res instanceof XPath2NodeIterator )
				{
					$this->childIter = $res;
				}
				else
				{
					$this->childIter = null;
					return $res instanceof XPathItem
						? $res
						: XPath2Item::fromValue( $res );
				}
			}
		}
	}