rator to allow lookahead and prepending elements.

Call :meth:`peek` on the result to get the value that will be returned
by :func:`next`. This won't advance the iterator:

    >>> p = peekable(['a', 'b'])
    >>> p.peek()
    'a'
    >>> next(p)
    'a'

Pass :meth:`peek` a default value to return that instead of raising
``StopIteration`` when the iterator is exhausted.

    >>> p = peekable([])
    >>> p.peek('hi')
    'hi'

peekables also offer a :meth:`prepend` method, which "inserts" items
at the head of the iterable:

    >>> p = peekable([1, 2, 3])
    >>> p.prepend(10, 11, 12)
    >>> next(p)
    10
    >>> p.peek()
    11
    >>> list(p)
    [11, 12, 1, 2, 3]

peekables can be indexed. Index 0 is the item that will be returned by
:func:`next`, index 1 is the item after that, and so on:
The values up to the given index will be cached.

    >>> p = peekable(['a', 'b', 'c', 'd'])
    >>> p[0]
    'a'
    >>> p[1]
    'b'
    >>> next(p)
    'a'

Negative indexes are supported, but be aware that they will cache the
remaining items in the source iterator, which may require significant
storage.

To check whether a peekable is exhausted, check its truth value:

    >>> p = peekable(['a', 'b'])
    >>> if p:  # peekable has items
    ...     list(p)
    ['a', 'b']
    >>> if not p:  # peekable is exhausted
    ...     list(p)
    []

c