# Trait nom::InputIter

source · [−]

    pub trait InputIter {
        type Item;
        type Iter: Iterator<Item = (usize, Self::Item)>;
        type IterElem: Iterator<Item = Self::Item>;

        fn iter_indices(&self) -> Self::Iter;
        fn iter_elements(&self) -> Self::IterElem;
        fn position<P>(&self, predicate: P) -> Option<usize>
        where
            P: Fn(Self::Item) -> bool;
        fn slice_index(&self, count: usize) -> Result<usize, Needed>;
    }

Expand description

Abstracts common iteration operations on the input type

## Required Associated Types

source

#### type Item

The current input type is a sequence of that `Item` type.

Example: `u8` for `&[u8]` or `char` for `&str`

source

#### type Iter: Iterator<Item = (usize, Self::Item)>

An iterator over the input type, producing the item and its position for use with Slice. If we’re iterating over `&str`, the position corresponds to the byte index of the character

source

#### type IterElem: Iterator<Item = Self::Item>

An iterator over the input type, producing the item

## Required Methods

source

#### fn iter_indices(&self) -> Self::Iter

Returns an iterator over the elements and their byte offsets

source

#### fn iter_elements(&self) -> Self::IterElem

Returns an iterator over the elements

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

Finds the byte position of the element

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

Get the byte offset from the element’s position in the stream

## Implementations on Foreign Types

source

### impl<'a> InputIter for &'a [u8]

#### type Item = u8

#### type Iter = Enumerate<<&'a [u8] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a str

#### type Item = char

#### type Iter = CharIndices<'a>

#### type IterElem = Chars<'a>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 0]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 0] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 1]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 1] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 2]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 2] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 3]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 3] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 4]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 4] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 5]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 5] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 6]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 6] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 7]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 7] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 8]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 8] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 9]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 9] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 10]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 10] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 11]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 11] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 12]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 12] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 13]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 13] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 14]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 14] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 15]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 15] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 16]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 16] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 17]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 17] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 18]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 18] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 19]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 19] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 20]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 20] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 21]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 21] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 22]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 22] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 23]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 23] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 24]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 24] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 25]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 25] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 26]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 26] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 27]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 27] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 28]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 28] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 29]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 29] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 30]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 30] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 31]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 31] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

source

### impl<'a> InputIter for &'a [ u8 ; 32]

#### type Item = u8

#### type Iter = Enumerate<<&'a [ u8 ; 32] as InputIter>::IterElem>

#### type IterElem = Copied<Iter<'a, u8>>

source

#### fn iter_indices(&self) -> Self::Iter

source

#### fn iter_elements(&self) -> Self::IterElem

source

#### fn position<P>(&self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool,

source

#### fn slice_index(&self, count: usize) -> Result<usize, Needed>

## Implementors