fn iter(&self) -> SequenceIter<Self> {
        SequenceIter {
            sequence: self,
            range: 0..self.len(),
        }
    }
/// Returns an iterator for the items in the sequence.
///
/// # A word of caution on modification during iteration
///
/// Many host-owned sequence can be modified during iteration. While this will never result in
/// undefined behavior, it may cause unexpected results. For example, one might expect the
/// following example to disconnect all of the element's child nodes from the DOM tree:
///
/// ```
/// for node in element.child_nodes().iter() {
///     node.disconnect()
/// }
/// ```
///
/// However, at the end of this loop, only nodes at even indices will have been disconnected,
/// nodes at odd indices will remain connected.
///
/// To achieve the desired result in the above example, one might for example do the following:
///
/// ```
/// let child_nodes = element.child_nodes();
///
/// while let Some(node) = child_nodes.last() {
///     node.disconnect()
/// }
/// ```
///
/// In general, caution is advised when modifying a sequence during iteration.
///
/// # A note on `Iterator::size_hint`
///
/// For sequences that are modifyable, the size hint may not remain accurate if the sequence is
/// modified during iteration. The size hint is always accurate if the sequence is never
/// modified during iteration.
Returns an iterator for the items in the sequence.
Returns an iterator for the items in the sequence .
fn iter(&self) -> SequenceIter<Self> {
        SequenceIter {
            sequence: self,
            range: 0..self.len(),
        }
    }
fn iter ( & self ) -> SequenceIter < Self > { SequenceIter { sequence : self , range : 0 .. self . len ( ) , } }
Returns an iterator for the items in the sequence.
Returns an iterator for the items in the sequence .
&self
&self
a word of caution on modification during iteration
Many host-owned sequence can be modified during iteration. While this will never result in
undefined behavior, it may cause unexpected results. For example, one might expect the
following example to disconnect all of the element's child nodes from the DOM tree.

```
for node in element.child_nodes().iter() {
node.disconnect()
}
```

However, at the end of this loop, only nodes at even indices will have been disconnected,
nodes at odd indices will remain connected.

To achieve the desired result in the above example, one might for example do the following.

```
let child_nodes = element.child_nodes().

while let Some(node) = child_nodes.last() {
node.disconnect()
}
```

In general, caution is advised when modifying a sequence during iteration.
Many host - owned sequence can be modified during iteration . While this will never result in undefined behavior it may cause unexpected results . For example one might expect the following example to disconnect all of the element ' s child nodes from the DOM tree . ` ` ` for node in element . child_nodes () . iter () { node . disconnect () } ` ` ` However at the end of this loop only nodes at even indices will have been disconnected nodes at odd indices will remain connected . To achieve the desired result in the above example one might for example do the following . ` ` ` let child_nodes = element . child_nodes () . while let Some ( node ) = child_nodes . last () { node . disconnect () } ` ` ` In general caution is advised when modifying a sequence during iteration .
a note on `iterator::size_hint`
For sequences that are modifyable, the size hint may not remain accurate if the sequence is
modified during iteration. The size hint is always accurate if the sequence is never
modified during iteration.
For sequences that are modifyable the size hint may not remain accurate if the sequence is modified during iteration . The size hint is always accurate if the sequence is never modified during iteration .