### Implement StreamingIterator for Once in Rust

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Once

Implements the core 'StreamingIterator' trait for the 'Once<T>' struct. This enables standard forward iteration with methods like 'advance', 'get', 'next', and 'size_hint'.

```rust
impl<T> StreamingIterator for Once<T> {
    type Item = T
    fn advance(&mut self)
    fn get(&self) -> Option<&Self::Item>
    fn size_hint(&self) -> (usize, Option<usize>)
    fn next(&mut self) -> Option<&Self::Item>
    fn is_done(&self) -> bool
}
```

--------------------------------

### Implement StreamingIterator for OnceWith

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.OnceWith

Implements the core `StreamingIterator` trait for `OnceWith`. This includes methods like `next`, `advance`, `get`, `size_hint`, and `is_done`, defining the basic streaming iteration behavior.

```rust
impl<T, F: FnOnce() -> T> StreamingIterator for OnceWith<T, F>
type Item = T
fn advance(&mut self)
fn get(&self) -> Option<&Self::Item>
fn size_hint(&self) -> (usize, Option<usize>)
fn next(&mut self) -> Option<&Self::Item>
fn is_done(&self) -> bool
```

--------------------------------

### StreamingIterator Implementation for Successors

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Successors

This section details the implementation of the `StreamingIterator` trait for the `Successors` struct. It defines the `Item` type and core methods like `advance`, `get`, and `next`. It also includes adaptors like `all`, `any`, `filter`, `map`, and others common to Rust iterators.

```rust
impl<T, F: FnMut(T) -> Option<T>> StreamingIterator for Successors<T, F> {
    type Item = T;

    fn advance(&mut self);
    fn get(&self) -> Option<&Self::Item>;
    fn size_hint(&self) -> (usize, Option<usize>);
    fn next(&mut self) -> Option<&Self::Item>;
    fn is_done(&self) -> bool;
    fn all<F>(&mut self, f: F) -> bool where Self: Sized, F: FnMut(&Self::Item) -> bool;
    fn any<F>(&mut self, f: F) -> bool where Self: Sized, F: FnMut(&Self::Item) -> bool;
    fn by_ref(&mut self) -> &mut Self where Self: Sized;
    fn chain<I>(self, other: I) -> Chain<Self, I> where Self: Sized, I: StreamingIterator<Item = Self::Item> + Sized;
    fn cloned(self) -> Cloned<Self> where Self: Sized, Self::Item: Clone;
    fn copied(self) -> Copied<Self> where Self: Sized, Self::Item: Copy;
    fn count(self) -> usize where Self: Sized;
    fn filter<F>(self, f: F) -> Filter<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> bool;
    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F> where Self: Sized, F: FnMut(&Self::Item) -> Option<B>;
    fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F> where Self: Sized, J: StreamingIterator, F: FnMut(&Self::Item) -> J;
    fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> Option<B>;
    fn find<F>(&mut self, f: F) -> Option<&Self::Item> where Self: Sized, F: FnMut(&Self::Item) -> bool;
    fn fuse(self) -> Fuse<Self> where Self: Sized;
    fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), Self: Sized;
    fn map<B, F>(self, f: F) -> Map<Self, B, F> where Self: Sized, F: FnMut(&Self::Item) -> B;
    fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F> where Self: Sized, F: FnMut(&Self::Item) -> B;
}
```

--------------------------------

### RepeatWith StreamingIterator Implementation

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.RepeatWith

Implements the `StreamingIterator` trait for `RepeatWith`. This allows `RepeatWith` to be used in streaming iterator contexts. It defines the `Item` type and provides core methods such as `advance`, `get`, `size_hint`, `next`, and `is_done`.

```rust
impl<T, F: FnMut() -> T> StreamingIterator for RepeatWith<T, F> {
    type Item = T;

    fn advance(&mut self) {
        // ... implementation details ...
    }

    fn get(&self) -> Option<&Self::Item> {
        // ... implementation details ...
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        // ... implementation details ...
    }

    fn next(&mut self) -> Option<&Self::Item> {
        // ... implementation details ...
    }

    fn is_done(&self) -> bool {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement StreamingIterator for FlatMap

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.FlatMap

Implements the `StreamingIterator` trait for the `FlatMap` struct. This enables `FlatMap` to function as a streaming iterator, providing methods like `advance`, `is_done`, `get`, and `next`. It also includes default implementations for other `StreamingIterator` methods like `fold`, `size_hint`, `all`, `any`, `by_ref`, `chain`, `cloned`, `copied`, `count`, `filter`, `filter_map`, `flat_map`, `filter_map_deref`, `find`, `fuse`, `inspect`, `map`, `map_deref`, and `map_ref`.

```rust
impl<I, J, F> StreamingIterator for FlatMap<I, J, F>
where I: StreamingIterator, F: FnMut(&I::Item) -> J, J: StreamingIterator,
Source§
#### type Item = <J as StreamingIterator>::Item
The type of the elements being iterated over.
Source§
#### fn advance(&mut self)
Advances the iterator to the next element. Read more
Source§
#### fn is_done(&self) -> bool
Checks if `get()` will return `None`.
Source§
#### fn get(&self) -> Option<&Self::Item>
Returns a reference to the current element of the iterator.
Source§
#### fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
where Self: Sized, Fold: FnMut(Acc, &Self::Item) -> Acc,
Reduces the iterator’s elements to a single, final value.
Source§
#### fn next(&mut self) -> Option<&Self::Item>
Advances the iterator and returns the next value. Read more
Source§
#### fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the iterator.
Source§
#### fn all<F>(&mut self, f: F) -> bool
where Self: Sized, F: FnMut(&Self::Item) -> bool,
Determines if all elements of the iterator satisfy a predicate.
Source§
#### fn any<F>(&mut self, f: F) -> bool
where Self: Sized, F: FnMut(&Self::Item) -> bool,
Determines if any elements of the iterator satisfy a predicate.
Source§
#### fn by_ref(&mut self) -> &mut Self
where Self: Sized,
Borrows an iterator, rather than consuming it. Read more
Source§
#### fn chain<I>(self, other: I) -> Chain<Self, I>
where Self: Sized, I: StreamingIterator<Item = Self::Item> + Sized,
Consumes two iterators and returns a new iterator that iterates over both in sequence.
Source§
#### fn cloned(self) -> Cloned<Self> ⓘ
where Self: Sized, Self::Item: Clone,
Produces a normal, non-streaming, iterator by cloning the elements of this iterator.
Source§
#### fn copied(self) -> Copied<Self>
where Self: Sized, Self::Item: Copy,
Produces a normal, non-streaming, iterator by copying the elements of this iterator.
Source§
#### fn count(self) -> usize
where Self: Sized,
Consumes the iterator, counting the number of remaining elements and returning it.
Source§
#### fn filter<F>(self, f: F) -> Filter<Self, F>
where Self: Sized, F: FnMut(&Self::Item) -> bool,
Creates an iterator which uses a closure to determine if an element should be yielded.
Source§
#### fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F>
where Self: Sized, F: FnMut(&Self::Item) -> Option<B>,
Creates an iterator which both filters and maps by applying a closure to elements.
Source§
#### fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>
where Self: Sized, J: StreamingIterator, F: FnMut(&Self::Item) -> J,
Creates an iterator which flattens iterators obtained by applying a closure to elements. Note that the returned iterators must be streaming iterators.
Source§
#### fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F> ⓘ
where Self: Sized, F: FnMut(&Self::Item) -> Option<B>,
Creates a regular, non-streaming iterator which both filters and maps by applying a closure to elements.
Source§
#### fn find<F>(&mut self, f: F) -> Option<&Self::Item>
where Self: Sized, F: FnMut(&Self::Item) -> bool,
Returns the first element of the iterator that satisfies the predicate.
Source§
#### fn fuse(self) -> Fuse<Self>
where Self: Sized,
Creates an iterator which is “well behaved” at the beginning and end of iteration. Read more
Source§
#### fn inspect<F>(self, f: F) -> Inspect<Self, F>
where F: FnMut(&Self::Item), Self: Sized,
Call a closure on each element, passing the element on. The closure is called upon calls to `advance` or `advance_back`, and exactly once per element regardless of how many times (if any) `get` is called.
Source§
#### fn map<B, F>(self, f: F) -> Map<Self, B, F>
where Self: Sized, F: FnMut(&Self::Item) -> B,
Creates an iterator which transforms elements of this iterator by passing them to a closure.
Source§
#### fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F> ⓘ
where Self: Sized, F: FnMut(&Self::Item) -> B,
Creates a regular, non-streaming iterator which transforms elements of this iterator by passing them to a closure.
Source§
#### fn map_ref<B: ?Sized, F>(self, f: F) -> MapRef<Self, F>
where Self: Sized, F: Fn(&Self::Item) -> &B,
Creates an iterator which transforms elements of this iterator by passing them to a closure. Read more
```

--------------------------------

### fuse

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/trait.StreamingIterator

Creates an iterator which is “well behaved” at the beginning and end of iteration. The behavior of calling `get` before iteration has been started, and of continuing to call `advance` after `get` has returned `None` is normally unspecified, but this guarantees that `get` will return `None` in both cases.

```APIDOC
## fuse

### Description
Creates an iterator which is “well behaved” at the beginning and end of iteration. The behavior of calling `get` before iteration has been started, and of continuing to call `advance` after `get` has returned `None` is normally unspecified, but this guarantees that `get` will return `None` in both cases.

### Method
`fuse`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Fuse<Self>** - A fused iterator.

#### Response Example
```json
{
  "fused_iterator": "<fused_iterator_representation>"
}
```
```

--------------------------------

### General Iterator and Borrowing Utilities

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.MapDeref

Provides documentation for fundamental iterator and borrowing operations, including type identification, borrowing, and conversion utilities.

```APIDOC
## General Iterator and Borrowing Utilities

### Description
This section covers utility functions for iterators and borrowing mechanisms.

### Methods

#### `type_id(&self) -> TypeId`
Gets the `TypeId` of `self`.

### `Borrow<T>` Trait

#### `borrow(&self) -> &T`
Immutably borrows from an owned value.

### `BorrowMut<T>` Trait

#### `borrow_mut(&mut self) -> &mut T`
Mutably borrows from an owned value.

### `From<T>` Trait

#### `from(t: T) -> T`
Returns the argument unchanged.

### `Into<U>` Trait

#### `into(self) -> U`
Calls `U::from(self)`.

### `TryFrom<U>` Trait

#### `type Error = Infallible`
The type returned in the event of a conversion error.

#### `try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
Performs the conversion.

### `TryInto<U>` Trait

#### `type Error = <U as TryFrom<T>>::Error`
The type returned in the event of a conversion error.

#### `try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
Performs the conversion.
```

--------------------------------

### Create a well-behaved fused iterator (Rust)

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/trait.StreamingIterator

The `fuse` method wraps an iterator to ensure predictable behavior at the start and end of iteration. Specifically, `get` will always return `None` before iteration begins or after `advance` has returned `None`, preventing unexpected states.

```rust
fn fuse(self) -> Fuse<Self>
where
    Self: Sized,
```

--------------------------------

### Iterator Adapters Documentation

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.MapDeref

This section outlines common iterator adapter methods, their purpose, and usage.

```APIDOC
## Iterator Adapters

This documentation describes various methods that can be called on Rust iterators to adapt their behavior.

### `for_each<F>(self, f: F)`

**Description**: Calls a closure on each element of an iterator.

**Method**: `for_each`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: None

### `filter<P>(self, predicate: P) -> Filter<Self, P>`

**Description**: Creates an iterator which uses a closure to determine if an element should be yielded.

**Method**: `filter`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `predicate` (Closure returning bool)

**Request Example**: N/A

**Response**: A `Filter` iterator.

### `filter_map<B, F>(self, f: F) -> FilterMap<Self, F>`

**Description**: Creates an iterator that both filters and maps elements.

**Method**: `filter_map`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `f` (Closure returning Option<B>)

**Request Example**: N/A

**Response**: A `FilterMap` iterator.

### `enumerate(self) -> Enumerate<Self>`

**Description**: Creates an iterator which gives the current iteration count as well as the next value.

**Method**: `enumerate`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: An `Enumerate` iterator.

### `peekable(self) -> Peekable<Self>`

**Description**: Creates an iterator that can peek at the next element without consuming it.

**Method**: `peekable`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: A `Peekable` iterator.

### `skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>`

**Description**: Creates an iterator that skips elements based on a predicate.

**Method**: `skip_while`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `predicate` (Closure returning bool)

**Request Example**: N/A

**Response**: A `SkipWhile` iterator.

### `take_while<P>(self, predicate: P) -> TakeWhile<Self, P>`

**Description**: Creates an iterator that yields elements based on a predicate.

**Method**: `take_while`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `predicate` (Closure returning bool)

**Request Example**: N/A

**Response**: A `TakeWhile` iterator.

### `map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>`

**Description**: Creates an iterator that both yields elements based on a predicate and maps.

**Method**: `map_while`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `predicate` (Closure returning Option<B>)

**Request Example**: N/A

**Response**: A `MapWhile` iterator.

### `skip(self, n: usize) -> Skip<Self>`

**Description**: Creates an iterator that skips the first `n` elements.

**Method**: `skip`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `n` (usize) - The number of elements to skip.

**Request Example**: N/A

**Response**: A `Skip` iterator.

### `take(self, n: usize) -> Take<Self>`

**Description**: Creates an iterator that yields the first `n` elements.

**Method**: `take`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `n` (usize) - The maximum number of elements to yield.

**Request Example**: N/A

**Response**: A `Take` iterator.

### `scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>`

**Description**: An iterator adapter which holds internal state and produces a new iterator.

**Method**: `scan`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `initial_state` (Any), `f` (Closure processing state and item)

**Request Example**: N/A

**Response**: A `Scan` iterator.

### `flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>`

**Description**: Creates an iterator that works like map, but flattens nested structure.

**Method**: `flat_map`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `f` (Closure returning an IntoIterator)

**Request Example**: N/A

**Response**: A `FlatMap` iterator.

### `flatten(self) -> Flatten<Self>`

**Description**: Creates an iterator that flattens nested structure.

**Method**: `flatten`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: A `Flatten` iterator.

### `map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>`

**Description**: Calls a function for each contiguous window of size `N` over `self` and returns an iterator over the outputs.

**Method**: `map_windows`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `f` (Closure processing a slice of size N)

**Request Example**: N/A

**Response**: A `MapWindows` iterator.

### `fuse(self) -> Fuse<Self>`

**Description**: Creates an iterator which ends after the first `None`.

**Method**: `fuse`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: A `Fuse` iterator.

### `inspect<F>(self, f: F) -> Inspect<Self, F>`

**Description**: Does something with each element of an iterator, passing the value on.

**Method**: `inspect`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `f` (Closure processing the item)

**Request Example**: N/A

**Response**: An `Inspect` iterator.

### `by_ref(&mut self) -> &mut Self`

**Description**: Creates a “by reference” adapter for this instance of `Iterator`.

**Method**: `by_ref`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: A mutable reference to the iterator.

### `collect<B>(self) -> B`

**Description**: Transforms an iterator into a collection.

**Method**: `collect`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: A collection of type `B`.

### `try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType`

**Description**: Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

**Method**: `try_collect`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: None

**Request Example**: N/A

**Response**: A fallible collection type.

### `collect_into<E>(self, collection: &mut E) -> &mut E`

**Description**: Collects all the items from an iterator into a collection.

**Method**: `collect_into`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `collection` (&mut E) - The collection to extend.

**Request Example**: N/A

**Response**: A mutable reference to the collection.

### `partition<B, F>(self, f: F) -> (B, B)`

**Description**: Consumes an iterator, creating two collections from it based on a predicate.

**Method**: `partition`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `f` (Closure returning bool)

**Request Example**: N/A

**Response**: A tuple of two collections.

### `partition_in_place<'a, T, P>(self, predicate: P) -> usize`

**Description**: Reorders the elements of this iterator _in-place_ according to a predicate.

**Method**: `partition_in_place`

**Endpoint**: N/A (Method on Iterator trait)

**Parameters**: `predicate` (Closure returning bool)

**Request Example**: N/A

**Response**: The number of `true` elements found.
```

--------------------------------

### Using StreamingIterator with while let

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/index

Demonstrates the recommended way to consume a `StreamingIterator` using a `while let` loop. This pattern is crucial for correctly working with mutable references to iterators.

```rust
while let Some(item) = iter.next() {
    // work with item
}
```

--------------------------------

### Type Information Retrieval

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.FromFn

Shows how to get the `TypeId` of a type using the `type_id` method. This is part of the `Any` trait and is useful for runtime type introspection.

```rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.
```

--------------------------------

### StreamingIterator Adapter Methods

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.RepeatWith

Demonstrates various adapter methods available on types implementing `StreamingIterator`. These include functional methods like `all`, `any`, `filter`, `map`, and utility methods like `cloned`, `count`, and `chain`.

```rust
// Example usage of some adapter methods:
// let result = iterator.filter(|item| /* condition */).map(|item| /* transformation */).collect::<Vec<_>>();
// let first_match = iterator.find(|item| /* condition */);
// let count = iterator.count();
```

--------------------------------

### StreamingIterator::is_done Method in Rust

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/trait.StreamingIterator

The `is_done` method checks if the iterator has reached its end, returning `true` if `get()` would return `None`.

```Rust
fn is_done(&self) -> bool { ... }
```

--------------------------------

### Reduce Streaming Iterator to Single Value

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Take

Reduces the elements of a streaming iterator to a single value by repeatedly applying a closure. It starts with an initial value and combines it with each element.

```rust
fn fold<B, F>(self, init: B, f: F) -> B
where
    Self: Sized,
    F: FnMut(B, &Self::Item) -> B,
```

--------------------------------

### From and Into Conversions (Rust)

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.WindowsMut

Standard Rust conversions. `From<T>` allows creating a type from another, while `Into<U>` provides the reverse conversion. `TryFrom` and `TryInto` offer fallible conversion methods, handling potential errors during the process.

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
where U: From<T>
```

```rust
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
where U: Into<T>
```

```rust
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Implement Standard Iterator Adaptors for OnceWith

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.OnceWith

Demonstrates the implementation of common iterator adaptor methods on `OnceWith` when it conforms to `StreamingIterator`. These include `all`, `any`, `filter`, `find`, and others, leveraging the underlying streaming capabilities.

```rust
fn all<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
fn by_ref(&mut self) -> &mut Self
fn chain<I>(self, other: I) -> Chain<Self, I>
fn cloned(self) -> Cloned<Self>
fn copied(self) -> Copied<Self>
fn count(self) -> usize
fn filter<F>(self, f: F) -> Filter<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F>
fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>
fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F>
fn find<F>(&mut self, f: F) -> Option<&Self::Item>
fn fuse(self) -> Fuse<Self>
```

--------------------------------

### StreamingIterator Trait Implementation for Once

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Once

The `StreamingIterator` trait is implemented for `Once<T>`. This is the core trait for streaming iterators, providing methods for getting the current item, advancing, and checking if the iterator is done.

```APIDOC
## Trait Implementation: StreamingIterator for Once<T>

### Description
Provides the fundamental streaming iterator functionality for the `Once` struct.

### Associated Types

#### `type Item = T`

*   **Description**: The type of the elements being iterated over.
```

```APIDOC
### Methods

#### `advance(&mut self)`

*   **Description**: Advances the iterator to the next element.

#### `get(&self) -> Option<&Self::Item>`

*   **Description**: Returns a reference to the current element of the iterator.

#### `size_hint(&self) -> (usize, Option<usize>)`

*   **Description**: Returns the bounds on the remaining length of the iterator. For `Once`, this will typically be `(1, Some(1))` before the item is yielded and `(0, Some(0))` afterwards.

#### `next(&mut self) -> Option<&Self::Item>`

*   **Description**: Advances the iterator and returns the next value. For `Once`, this will return `Some(&item)` on the first call and `None` subsequently.

#### `is_done(&self) -> bool`

*   **Description**: Checks if `get()` will return `None`. Returns `true` after the single item has been yielded.

#### `all<F>(&mut self, f: F) -> bool`
*   **Description**: Determines if all elements of the iterator satisfy a predicate. For `Once`, this checks if the single element satisfies the predicate.
*   **Type Parameters**:
    *   `F`: The type of the closure, which takes a reference to an item and returns a boolean.

#### `any<F>(&mut self, f: F) -> bool`
*   **Description**: Determines if any elements of the iterator satisfy a predicate. For `Once`, this checks if the single element satisfies the predicate.
*   **Type Parameters**:
    *   `F`: The type of the closure, which takes a reference to an item and returns a boolean.

#### `by_ref(&mut self) -> &mut Self`

*   **Description**: Borrows an iterator, rather than consuming it.

#### `chain<I>(self, other: I) -> Chain<Self, I>`
*   **Description**: Consumes two iterators and returns a new iterator that iterates over both in sequence.
*   **Type Parameters**:
    *   `I`: The type of the other iterator, which must also be a `StreamingIterator` with the same item type.

#### `cloned(self) -> Cloned<Self>`

*   **Description**: Produces a normal, non-streaming, iterator by cloning the elements of this iterator. Requires `Self::Item` to be `Clone`.

#### `copied(self) -> Copied<Self>`

*   **Description**: Produces a normal, non-streaming, iterator by copying the elements of this iterator. Requires `Self::Item` to be `Copy`.

#### `count(self) -> usize`

*   **Description**: Consumes the iterator, counting the number of remaining elements and returning it.

#### `filter<F>(self, f: F) -> Filter<Self, F>`
*   **Description**: Creates an iterator which uses a closure to determine if an element should be yielded.
*   **Type Parameters**:
    *   `F`: The type of the closure, which takes a reference to an item and returns a boolean.

#### `filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F>`
*   **Description**: Creates an iterator which both filters and maps by applying a closure to elements.
*   **Type Parameters**:
    *   `B`: The type of the mapped elements.
    *   `F`: The type of the closure, which takes a reference to an item and returns an `Option<B>`.

#### `flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>`
*   **Description**: Creates an iterator which flattens iterators obtained by applying a closure to elements. Note that the returned iterators must be streaming iterators.
*   **Type Parameters**:
    *   `J`: The type of the flattened iterator, which must be a `StreamingIterator`.
    *   `F`: The type of the closure, which takes a reference to an item and returns a `J`.

#### `filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F>`

*   **Description**: Creates a regular, non-streaming iterator which both filters and maps by applying a closure to elements.
*   **Type Parameters**:
    *   `B`: The type of the mapped elements.
    *   `F`: The type of the closure, which takes a reference to an item and returns an `Option<B>`.

#### `find<F>(&mut self, f: F) -> Option<&Self::Item>`
*   **Description**: Returns the first element of the iterator that satisfies the predicate.
*   **Type Parameters**:
    *   `F`: The type of the closure, which takes a reference to an item and returns a boolean.

#### `fuse(self) -> Fuse<Self>`

*   **Description**: Creates an iterator which is “well behaved” at the beginning and end of iteration.
```

--------------------------------

### StreamingIterator Methods

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Inspect

Common methods available on StreamingIterator, such as map, filter, skip, and take.

```APIDOC
## Iterator Transformations

### `inspect<F>(self, f: F) -> Inspect<Self, F>`

**Description**: Calls a closure on each element, passing the element on. The closure is called upon calls to `advance` or `advance_back`, and exactly once per element regardless of how many times (if any) `get` is called.

### `map<B, F>(self, f: F) -> Map<Self, B, F>`

**Description**: Creates an iterator which transforms elements of this iterator by passing them to a closure.

### `map_deref<B, F>(self, f: F) -> MapDeref<Self, F>`

**Description**: Creates a regular, non-streaming iterator which transforms elements of this iterator by passing them to a closure.

### `map_ref<B: ?Sized, F>(self, f: F) -> MapRef<Self, F>`

**Description**: Creates an iterator which transforms elements of this iterator by passing them to a closure.

### `nth(&mut self, n: usize) -> Option<&Self::Item>`

**Description**: Consumes the first `n` elements of the iterator, returning the next one.

### `owned(self) -> Owned<Self>`

**Description**: Creates a normal, non-streaming, iterator with elements produced by calling `to_owned` on the elements of this iterator.

### `position<F>(&mut self, f: F) -> Option<usize>`

**Description**: Returns the index of the first element of the iterator matching a predicate.

### `skip(self, n: usize) -> Skip<Self>`

**Description**: Creates an iterator which skips the first `n` elements.

### `skip_while<F>(self, f: F) -> SkipWhile<Self, F>`

**Description**: Creates an iterator that skips initial elements matching a predicate.

### `take(self, n: usize) -> Take<Self>`

**Description**: Creates an iterator which only returns the first `n` elements.

### `take_while<F>(self, f: F) -> TakeWhile<Self, F>`

**Description**: Creates an iterator which only returns initial elements matching a predicate.

### `rev(self) -> Rev<Self>`

**Description**: Creates an iterator which returns elements in the opposite order. Requires `DoubleEndedStreamingIterator`.

### `for_each<F>(self, f: F)`

**Description**: Calls a closure on each element of an iterator.
```

--------------------------------

### Blanket Implementations

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.WindowsMut

Common blanket implementations available for generic types.

```APIDOC
## Blanket Implementations

### `impl<T> Any for T`

Provides the `type_id` method, allowing runtime type identification.

#### `fn type_id(&self) -> TypeId`

Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`

Allows an owned value to be borrowed immutably.

#### `fn borrow(&self) -> &T`

Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`

Allows an owned value to be borrowed mutably.

#### `fn borrow_mut(&mut self) -> &mut T`

Mutably borrows from an owned value.

### `impl<T> From<T> for T`

Provides a way to convert a value into itself.

#### `fn from(t: T) -> T`

Returns the argument unchanged.

### `impl<T, U> Into<U> for T where U: From<T>`

Provides a way to convert a type `T` into another type `U` if `U` can be created from `T`.

#### `fn into(self) -> U`

Calls `U::from(self)`.

### `impl<T, U> TryFrom<U> for T where U: Into<T>`

Provides a fallible way to convert a type `U` into another type `T`.

#### `type Error = Infallible`

Represents the type of error that can occur during conversion (in this case, none).

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

Performs the conversion.

### `impl<T, U> TryInto<U> for T where U: TryFrom<T>`

Provides a fallible way to convert a type `T` into another type `U`.

#### `type Error = <U as TryFrom<T>>::Error`

Represents the type of error that can occur during conversion.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

Performs the conversion.
```

--------------------------------

### Get Mutable Reference to Current Element (Rust)

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Convert

Returns a mutable reference to the current element of a `Convert` streaming iterator. This allows in-place modification of the iterator's current item.

```rust
fn get_mut(&mut self) -> Option<&mut I::Item>
where I: Iterator
```

--------------------------------

### Blanket Implementations

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.RepeatWith

Details blanket implementations provided for iterators, offering common functionalities.

```APIDOC
## GET /iterator/blanket_implementations

### Description
Lists blanket implementations available for iterators, providing general utility functions.

### Method
GET

### Endpoint
/iterator/blanket_implementations

### Parameters
#### Query Parameters
- **trait_name** (string) - Optional - The name of the blanket trait to get details for (e.g., 'Borrow', 'CloneToUninit').

### Response
#### Success Response (200)
- **trait_name** (string) - The name of the blanket trait.
- **description** (string) - A brief explanation of the trait's purpose.
- **methods** (array) - An array of method objects, each with 'name', 'description', 'parameters', and 'return_type'.

#### Response Example
```json
{
  "implementations": [
    {
      "trait_name": "Borrow<T>",
      "description": "Provides immutable access to the underlying data.",
      "methods": [
        {
          "name": "borrow",
          "description": "Immutably borrows from an owned value.",
          "parameters": [],
          "return_type": "&T"
        }
      ]
    },
    {
      "trait_name": "CloneToUninit",
      "description": "Provides functionality to clone into uninitialized memory (nightly only).",
      "methods": [
        {
          "name": "clone_to_uninit",
          "description": "Performs copy-assignment from `self` to `dest`.",
          "parameters": [
            {
              "name": "dest",
              "type": "*mut u8",
              "description": "A mutable pointer to the destination memory."
            }
          ],
          "return_type": "unsafe fn"
        }
      ]
    }
  ]
}
```
```

--------------------------------

### Get Type ID - Rust

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.ConvertRef

The `type_id` method, part of the `Any` trait implementation, returns the unique `TypeId` of the current type. This is useful for runtime type introspection.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### rfold Method Documentation (Rust)

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/trait.DoubleEndedStreamingIterator

Details the `rfold` method, a provided method for DoubleEndedStreamingIterator. It reduces the iterator's elements into a single value starting from the back.

```rust
fn rfold<B, F>(self, init: B, f: F) -> B
where Self: Sized,
      F: FnMut(B, &Self::Item) -> B,
Reduces the iterator’s elements to a single, final value, starting from the back.
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Repeat

Details the `TryFrom` and `TryInto` trait implementations for type conversions within the streaming iterator.

```APIDOC
## TryFrom and TryInto Trait Implementations

### Description
Enables fallible type conversions between different types within the streaming iterator, using `TryFrom` and `TryInto`.

### `TryFrom<U>` Implementation
- **Type `Error`**: `Infallible`
  - **Description**: The type returned in the event of a conversion error (infallible means no errors).
- **Method `try_from`**
  - **Description**: Performs the conversion from type `U` into type `T`.
  - **Parameters**:
    - **value** (`U`) - The value to convert.
  - **Returns**: `Result<T, <T as TryFrom<U>>::Error>` - The result of the conversion.

### `TryInto<U>` Implementation
- **Type `Error`**: `<U as TryFrom<T>>::Error`
  - **Description**: The type returned in the event of a conversion error.
- **Method `try_into`**
  - **Description**: Performs the conversion from type `T` into type `U`.
  - **Returns**: `Result<U, <U as TryFrom<T>>::Error>` - The result of the conversion.
```

--------------------------------

### Standard Iterator and Borrowing Methods

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.FilterMapDeref

Documentation for standard iterator and borrowing methods available for types.

```APIDOC
## Standard Iterator and Borrowing Methods

### Description
This section details common traits like `Borrow`, `BorrowMut`, `From`, `Into`, and `Iterator` which are fundamental for data manipulation and iteration.

### `impl<I> IntoIterator for I where I: Iterator`

*   **Description**: Allows types that are already iterators to be used in contexts expecting an `IntoIterator`.
*   **Associated Types**: 
    *   `Item = <I as Iterator>::Item`: The type of elements yielded by the iterator.
    *   `IntoIter = I`: The type of the iterator itself.
*   **Method**: `into_iter(self) -> I` - Creates an iterator from a value.

### `impl<T> Borrow<T> for T`

*   **Description**: Enables immutable borrowing.
*   **Method**: `borrow(&self) -> &T` - Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`

*   **Description**: Enables mutable borrowing.
*   **Method**: `borrow_mut(&mut self) -> &mut T` - Mutably borrows from an owned value.

### `impl<T> From<T> for T`

*   **Description**: A simple conversion where a value is converted into itself.
*   **Method**: `from(t: T) -> T` - Returns the argument unchanged.

### `impl<T, U> Into<U> for T where U: From<T>`

*   **Description**: Provides a convenient way to convert a type `T` into a type `U` if `U` implements `From<T>`.
*   **Method**: `into(self) -> U` - Calls `U::from(self)`.
```

--------------------------------

### StreamingIterator Implementation for Skip

Source: https://docs.rs/streaming-iterator/latest/streaming_iterator/struct.Skip

Details the implementation of the `StreamingIterator` trait for the `Skip` struct, including methods for advancing, checking if done, getting the current element, and more.

```APIDOC
## impl<I> StreamingIterator for Skip<I>

### Description
This block details the implementation of the `StreamingIterator` trait for the `Skip` struct.

### Methods
* **`item`**: `type Item = <I as StreamingIterator>::Item` - The type of the elements being iterated over.
* **`advance`**: `fn advance(&mut self)` - Advances the iterator to the next element.
* **`is_done`**: `fn is_done(&self) -> bool` - Checks if `get()` will return `None`.
* **`get`**: `fn get(&self) -> Option<&I::Item>` - Returns a reference to the current element of the iterator.
* **`size_hint`**: `fn size_hint(&self) -> (usize, Option<usize>)` - Returns the bounds on the remaining length of the iterator.
* **`fold`**: `fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc` - Reduces the iterator’s elements to a single, final value.
* **`next`**: `fn next(&mut self) -> Option<&Self::Item>` - Advances the iterator and returns the next value.
* **`all`**: `fn all<F>(&mut self, f: F) -> bool` - Determines if all elements of the iterator satisfy a predicate.
* **`any`**: `fn any<F>(&mut self, f: F) -> bool` - Determines if any elements of the iterator satisfy a predicate.
* **`by_ref`**: `fn by_ref(&mut self) -> &mut Self` - Borrows an iterator, rather than consuming it.
* **`chain`**: `fn chain<I>(self, other: I) -> Chain<Self, I>` - Consumes two iterators and returns a new iterator that iterates over both in sequence.
* **`cloned`**: `fn cloned(self) -> Cloned<Self>` - Produces a normal, non-streaming, iterator by cloning the elements of this iterator.
* **`copied`**: `fn copied(self) -> Copied<Self>` - Produces a normal, non-streaming, iterator by copying the elements of this iterator.
* **`count`**: `fn count(self) -> usize` - Consumes the iterator, counting the number of remaining elements and returning it.
* **`filter`**: `fn filter<F>(self, f: F) -> Filter<Self, F>` - Creates an iterator which uses a closure to determine if an element should be yielded.
* **`filter_map`**: `fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F>` - Creates an iterator which both filters and maps by applying a closure to elements.
* **`flat_map`**: `fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>` - Creates an iterator which flattens iterators obtained by applying a closure to elements.
* **`filter_map_deref`**: `fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F>` - Creates a regular, non-streaming iterator which both filters and maps by applying a closure to elements.
* **`find`**: `fn find<F>(&mut self, f: F) -> Option<&Self::Item>` - Returns the first element of the iterator that satisfies the predicate.
* **`fuse`**: `fn fuse(self) -> Fuse<Self>` - Creates an iterator which is “well behaved” at the beginning and end of iteration.
* **`inspect`**: `fn inspect<F>(self, f: F) -> Inspect<Self, F>` - Call a closure on each element, passing the element on.
* **`map`**: `fn map<B, F>(self, f: F) -> Map<Self, B, F>` - Creates an iterator which transforms elements of this iterator by passing them to a closure.
* **`map_deref`**: `fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F>` - Creates a regular, non-streaming iterator which transforms elements of this iterator by passing them to a closure.
```