itself),
and whenever finding a Stream subclass in self,
that Stream subclass's elements.

Here's an example. Let's create a simple score.

>>> s = stream.Score(id='mainScore')
>>> p0 = stream.Part(id='part0')
>>> p1 = stream.Part(id='part1')

>>> m01 = stream.Measure(number=1)
>>> m01.append(note.Note('C', type='whole'))
>>> m02 = stream.Measure(number=2)
>>> m02.append(note.Note('D', type='whole'))
>>> m11 = stream.Measure(number=1)
>>> m11.append(note.Note('E', type='whole'))
>>> m12 = stream.Measure(number=2)
>>> m12.append(note.Note('F', type='whole'))

>>> p0.append([m01, m02])
>>> p1.append([m11, m12])

>>> s.insert(0, p0)
>>> s.insert(0, p1)
>>> s.show('text')
{0.0} <music21.stream.Part part0>
    {0.0} <music21.stream.Measure 1 offset=0.0>
        {0.0} <music21.note.Note C>
    {4.0} <music21.stream.Measure 2 offset=4.0>
        {0.0} <music21.note.Note D>
{0.0} <music21.stream.Part part1>
    {0.0} <music21.stream.Measure 1 offset=0.0>
        {0.0} <music21.note.Note E>
    {4.0} <music21.stream.Measure 2 offset=4.0>
        {0.0} <music21.note.Note F>

Now we could assign the `.recurse()` method to something,
but that won't have much effect:

>>> sRecurse = s.recurse()
>>> sRecurse
<music21.stream.iterator.RecursiveIterator for Score:mainScore @:0>

So, that's not how we use `.recurse()`.  Instead, use it in a `for` loop:

>>> for el in s.recurse():
...     tup = (el, el.offset, el.activeSite)
...     print(tup)
(<music21.stream.Part part0>, 0.0, <music21.stream.Score mainScore>)
(<music21.stream.Measure 1 offset=0.0>, 0.0, <music21.stream.Part part0>)
(<music21.note.Note C>, 0.0, <music21.stream.Measure 1 offset=0.0>)
(<music21.stream.Measure 2 offset=4.0>, 4.0, <music21.stream.Part part0>)
(<music21.note.Note D>, 0.0, <music21.stream.Measure 2 offset=4.0>)
(<music21.stream.Part part1>, 0.0, <music21.stream.Score mainScore>)
(<music21.stream.Measure 1 offset=0.0>, 0.0, <music21.stream.Part part1>)
(<music21.note.Note E>, 0.0, <music21.stream.Measure 1 offset=0.0>)
(<music21.stream.Measure 2 offset=4.0>, 4.0, <music21.stream.Part part1>)
(<music21.note.Note F>, 0.0, <music21.stream.Measure 2 offset=4.0>)

If we specify `includeSelf=True` then the original stream is also iterated:

>>> for el in s.recurse(includeSelf=True):
...     tup = (el, el.offset, el.activeSite)
...     print(tup)
(<music21.stream.Score mainScore>, 0.0, None)
(<music21.stream.Part part0>, 0.0, <music21.stream.Score mainScore>)
(<music21.stream.Measure 1 offset=0.0>, 0.0, <music21.stream.Part part0>)
(<music21.note.Note C>, 0.0, <music21.stream.Measure 1 offset=0.0>)
...

Notice that like calling `.show('text')`, the offsets are relative to their containers.

Compare the difference between putting `.recurse().notes` and `.flatten().notes`:

>>> for el in s.recurse().notes:
...     tup = (el, el.offset, el.activeSite)
...     print(tup)
(<music21.note.Note C>, 0.0, <music21.stream.Measure 1 offset=0.0>)
(<music21.note.Note D>, 0.0, <music21.stream.Measure 2 offset=4.0>)
(<music21.note.Note E>, 0.0, <music21.stream.Measure 1 offset=0.0>)
(<music21.note.Note F>, 0.0, <music21.stream.Measure 2 offset=4.0>)

>>> for el in s.flatten().notes:
...     tup = (el, el.offset, el.activeSite)
...     print(tup)
(<music21.note.Note C>, 0.0, <music21.stream.Score mainScore_flat>)
(<music21.note.Note E>, 0.0, <music21.stream.Score mainScore_flat>)
(<music21.note.Note D>, 4.0, <music21.stream.Score mainScore_flat>)
(<music21.note.Note F>, 4.0, <music21.stream.Score mainScore_flat>)

If you don't need correct offsets or activeSites, set `restoreActiveSites` to `False`.
Then the last offset/activeSite will be used.  It's a bit of a speedup, but leads to some
bad code, so use it only in highly optimized situations.

We'll also test using multiple classes here. The Stream given is the same as the
s.flatten().notes stream.

>>> for el in s.recurse(classFilter=('Note', 'Rest'), restoreActiveSites=False):
...     tup = (el, el.offset, el.activeSite)
...     print(tup)
(<music21.note.Note C>, 0.0, <music21.stream.Score mainScore_flat>)
(<music21.note.Note D>, 4.0, <music21.stream.Score mainScore_flat>)
(<music21.note.Note E>, 0.0, <music21.stream.Score mainScore_flat>)
(<music21.note.Note F>, 4.0, <music21.stream.Score mainScore_flat>)

So, this is pretty unreliable so don't use it unless the tiny speedup is worth it.

The other two attributes are pretty self-explanatory: `streamsOnly` will put only Streams
in, while `includeSelf` will add the initial stream from recursion.  If the inclusion or
exclusion of `self` is important to you, put it in explicitly.

>>> for el in s.recurse(includeSelf=False, streamsOnly=True):
...     tup = (el, el.offset, el.activeSite)
...     print(tup)
(<music21.stream.Part part0>, 0.0, <music21.stream.Score mainScore>)
(<music21.stream.Measure 1 offset=0.0>, 0.0, <music21.stream.Part part0>)
(<music21.stream.Measure 2 offset=4.0>, 4.0, <music21.stream.Part part0>)
(<music21.stream.Part part1>, 0.0, <music21.stream.Score mainScore>)
(<music21.stream.Measure 1 offset=0.0>, 0.0, <music21.stream.Part part1>)
(<music21.stream.Measure 2 offset=4.0>, 4.0, <music21.stream.Part part1>)

.. warning::

    Remember that like all iterators, it is dangerous to alter
    the components of the Stream being iterated over during iteration.
    if you need to edit while recursing, list(s.recurse()) is safer.

* Changed in v5.5: All attributes are keyword only.
* Changed in v8: removed parameter `skipSelf`.  Use `includeSelf` instead.
)