Ungrammar

https://docs.rs/ungrammar/1.16.1/ungrammar/
Admin
Ungrammar is a Domain-Specific Language for specifying concrete syntax tree grammars without the...
Tokens:19,601
Snippets:136
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### GET /Grammar/Node

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Node.html

Retrieves NodeData by indexing a Grammar with a Node.

```APIDOC
## GET /Grammar/Node

### Description
Performs the indexing operation (container[index]) to retrieve NodeData associated with a specific Node within a Grammar.

### Method
GET

### Endpoint
Grammar[Node]

### Parameters
#### Path Parameters
- **Node** (Node) - Required - The node instance used to index the grammar.

### Response
#### Success Response (200)
- **Output** (NodeData) - The data associated with the requested node.
```

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

### Get Error Description (Deprecated)

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Deprecated method to get a string description of the error. Use the Display impl or to_string() instead.

```rust
fn description(&self) -> &str
```

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

### Unwrap Ok Value

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Use `unwrap` to get the contained `Ok` value. Panics if the value is an `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

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

### Get Rust Grammar

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/fn.rust_grammar.html

Returns a pre-defined Grammar object for Rust. This is useful for parsing or analyzing Rust code.

```rust
pub fn rust_grammar() -> Grammar
```

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

### Get Error Source

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Returns the lower-level source of this error, if any. This is part of the standard Error trait implementation.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

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

### Unwrap Error Value

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Use `unwrap_err` to get the contained `Err` value. Panics if the value is an `Ok`.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

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

### into_ok

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained `Ok` value, but never panics. This is a nightly-only experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
`into_ok()`

### Examples
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

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

### Get Type ID

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Gets the `TypeId` of `self`. This is a blanket implementation for any type `T` that is 'static and ?Sized.

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

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

### Core Data Structures

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/all.html

Overview of the primary data structures used in the ungrammar crate.

```APIDOC
## Data Structures

### Structs
- **Error**: Represents errors encountered during grammar processing.
- **Grammar**: The primary structure representing the full grammar.
- **Node**: Represents a node within the grammar tree.
- **NodeData**: Data associated with a specific grammar node.
- **Token**: Represents a token in the grammar.
- **TokenData**: Data associated with a specific grammar token.

### Enums
- **Rule**: Defines the rules applicable within the grammar.
```

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

### Get Error Cause (Deprecated)

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Deprecated method to get the underlying cause of the error. Replaced by Error::source.

```rust
fn cause(&self) -> Option<&dyn Error>
```

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

### try_into Method

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Token.html

Provides the method for performing fallible conversions.

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

### Description
Performs the conversion from type T to type U, returning a Result.

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

### Returns
A `Result` which is `Ok(U)` on success or `Err(<U as TryFrom<T>>::Error)` on failure.
```

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

### Function: rust_grammar

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/index.html

Retrieves the predefined Rust grammar structure.

```APIDOC
## rust_grammar

### Description
Returns a predefined Rust grammar object.

### Response
- **Grammar** (Struct) - The grammar object representing Rust syntax.
```

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

### Token Trait Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Token.html

Details the various trait implementations for the Token struct, showcasing its capabilities for cloning, debugging, hashing, indexing, comparison, and equality checks.

```APIDOC
## Trait Implementations

### impl Clone for Token
#### fn clone(&self) -> Token
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### impl Debug for Token
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

### impl Hash for Token
#### fn hash<__H: Hasher>(&self, state: &mut __H)
Feeds this value into the given `Hasher`.

#### fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,
Feeds a slice of this type into the given `Hasher`.

### impl Index<Token> for Grammar
#### type Output = TokenData
The returned type after indexing.

#### fn index(&self, Token: Token) -> &TokenData
Performs the indexing (`container[index]`) operation.

### impl Ord for Token
#### fn cmp(&self, other: &Token) -> Ordering
This method returns an `Ordering` between `self` and `other`.

#### fn max(self, other: Self) -> Self
where Self: Sized,
Compares and returns the maximum of two values.

#### fn min(self, other: Self) -> Self
where Self: Sized,
Compares and returns the minimum of two values.

#### fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,
Restrict a value to a certain interval.

### impl PartialEq for Token
#### fn eq(&self, other: &Token) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.

### impl PartialOrd for Token
#### fn partial_cmp(&self, other: &Token) -> Option<Ordering>
This method returns an ordering between `self` and `other` values if one exists.

#### fn lt(&self, other: &Rhs) -> bool
Tests less than (for `self` and `other`) and is used by the `<` operator.

#### fn le(&self, other: &Rhs) -> bool
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

#### fn gt(&self, other: &Rhs) -> bool
Tests greater than (for `self` and `other`) and is used by the `>` operator.

#### fn ge(&self, other: &Rhs) -> bool
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

### impl Copy for Token

### impl Eq for Token

### impl StructuralPartialEq for Token
```

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

### Grammar Parsing

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Grammar.html

Parsing a string into a Grammar instance.

```APIDOC
## FromStr for Grammar

### Description
Parses a string to return a Grammar instance.

### Parameters
#### Request Body
- **s** (str) - Required - The string representation of the grammar.

### Response
#### Success Response (200)
- **Grammar** - The parsed grammar object.

#### Error Response
- **Error** - The error returned if parsing fails.
```

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

### impl<T, U, E> Product<Result<U, E>> for Result<T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides the Product trait implementation for Result, allowing the product of an iterator of Results to be computed.

```APIDOC
### impl<T, U, E> Product<Result<U, E>> for Result<T, E>

#### Description
This implementation allows computing the product of an iterator of `Result<U, E>` values, where the final result is a `Result<T, E>`. It requires that `T` implements `Product<U>`.
```

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

### impl<T, E> PartialEq for Result<T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides equality comparison for Result types, requiring that both Ok and Err types implement PartialEq.

```APIDOC
## fn eq(&self, other: &Result<T, E>) -> bool

### Description
Tests for equality between two `Result` values. Requires `T: PartialEq` and `E: PartialEq`.

### Method
`eq`

### Parameters
- **other** (&Result<T, E>): The other `Result` to compare against.

### Response
#### Success Response (bool)
- **bool**: `true` if the `Result` values are equal, `false` otherwise.

## fn ne(&self, other: &Rhs) -> bool

### Description
Tests for inequality between two `Result` values. Requires `T: PartialEq` and `E: PartialEq`.

### Method
`ne`

### Parameters
- **other**: The other value to compare against.

### Response
#### Success Response (bool)
- **bool**: `true` if the `Result` values are not equal, `false` otherwise.
```

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

### Expect Error Value with Custom Panic Message

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Use `expect_err` to get the contained `Err` value. Panics if the value is an `Ok`, including the provided message and the `Ok`'s content.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

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

### try_into Method

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Node.html

Provides a method to attempt a conversion that may fail, returning a `Result`.

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

### Description
Performs the conversion.

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

### Return Value
A `Result` which is `Ok` if the conversion was successful, or `Err` containing the conversion error if it failed.
```

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

### Clone Result<&mut T, E> to Result<T, E> in Rust

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Maps a `Result` containing a mutable reference to a value to a `Result` containing the cloned value. Requires the contained type `T` to implement the `Clone` trait. Use this to get an owned, cloned value from a mutable reference in a `Result`.

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

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

### Collect Result Iterators

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Demonstrates how to collect an iterator of Results into a Result containing a collection, with short-circuiting behavior on error.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

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

### Provide Error Context (Nightly Only)

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Experimental, nightly-only API to provide type-based access to error context for error reporting.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

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

### Result Trait Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Overview of standard trait implementations for the Result type.

```APIDOC
### impl<T, E> Try for Result<T, E>

#### type Output = T

#### type Residual = Result<Infallible, E>

#### fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

#### fn branch( self, ) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

### impl<T, E> Copy for Result<T, E>

### impl<T, E> Eq for Result<T, E>

### impl<T, E> StructuralPartialEq for Result<T, E>

### impl<T, E> UseCloned for Result<T, E>
```

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

### expect

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained Ok value, consuming the self value, or panics if the value is an Err.

```APIDOC
## expect

### Description
Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`, with a panic message including the passed message.

### Parameters
- **msg** (&str) - Required - The message to include in the panic if the result is an Err.
```

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

### Create references to Result contents with as_ref and as_mut

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Converts a Result reference into a Result containing references to the original values.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### Implementations for Result<T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Core methods for checking the status of a Result.

```APIDOC
## impl<T, E> Result<T, E>

### Methods

#### `is_ok`
```rust
pub const fn is_ok(&self) -> bool
```
Returns `true` if the result is `Ok`.

##### Examples
```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

#### `is_ok_and`
```rust
pub fn is_ok_and<F>(self, f: F) -> bool
where F: FnOnce(T) -> bool,
```
Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

##### Examples
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

#### `is_err`
```rust
pub const fn is_err(&self) -> bool
```
Returns `true` if the result is `Err`.

##### Examples
```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

#### `is_err_and`
```rust
pub fn is_err_and<F>(self, f: F) -> bool
where F: FnOnce(E) -> bool,
```
Returns `true` if the result is `Err` and the value inside of it matches a predicate.
```

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

### rust_grammar Function

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/all.html

Retrieves the Rust grammar definition.

```APIDOC
## rust_grammar

### Description
Returns the grammar definition for Rust.

### Returns
- **Grammar** - The parsed grammar structure.
```

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

### Core Structures

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/index.html

Overview of the primary data structures used to define the grammar.

```APIDOC
## Core Structures

### Grammar
- **Description**: The main container for an Ungrammar grammar.

### Node
- **Description**: Represents a node in the grammar, defined as `A = 'b' | 'c'`.

### Token
- **Description**: Represents a terminal token, denoted with single quotes (e.g., '+' or 'struct').

### Rule
- **Description**: An enum representing a production rule within the grammar.
```

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

### Result Conversion Methods

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Methods for converting Result to Option or handling references.

```APIDOC
## pub fn ok(self) -> Option<T>

### Description
Converts from Result<T, E> to Option<T>, consuming self and discarding the error if any.

### Response
- **Option<T>** - The success value if Ok, otherwise None.

## pub fn err(self) -> Option<E>

### Description
Converts from Result<T, E> to Option<E>, consuming self and discarding the success value if any.

### Response
- **Option<E>** - The error value if Err, otherwise None.

## pub const fn as_ref(&self) -> Result<&T, &E>

### Description
Converts from &Result<T, E> to Result<&T, &E>.

### Response
- **Result<&T, &E>** - A new Result containing references into the original.
```

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

### impl<T, E> PartialOrd for Result<T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides partial ordering for Result types, requiring that both Ok and Err types implement PartialOrd.

```APIDOC
## fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

### Description
Compares two `Result` values and returns an `Option<Ordering>` if a comparison is possible. Requires `T: PartialOrd` and `E: PartialOrd`.

### Method
`partial_cmp`

### Parameters
- **other** (&Result<T, E>): The other `Result` to compare against.

### Response
#### Success Response (Option<Ordering>)
- **Option<Ordering>** : An `Option` containing an `Ordering` enum value (`Less`, `Equal`, `Greater`) if comparable, otherwise `None`.

## fn lt(&self, other: &Rhs) -> bool

### Description
Tests if `self` is less than `other`. Requires `T: PartialOrd` and `E: PartialOrd`.

### Method
`lt`

### Parameters
- **other**: The other value to compare against.

### Response
#### Success Response (bool)
- **bool**: `true` if `self` is less than `other`, `false` otherwise.

## fn le(&self, other: &Rhs) -> bool

### Description
Tests if `self` is less than or equal to `other`. Requires `T: PartialOrd` and `E: PartialOrd`.

### Method
`le`

### Parameters
- **other**: The other value to compare against.

### Response
#### Success Response (bool)
- **bool**: `true` if `self` is less than or equal to `other`, `false` otherwise.

## fn gt(&self, other: &Rhs) -> bool

### Description
Tests if `self` is greater than `other`. Requires `T: PartialOrd` and `E: PartialOrd`.

### Method
`gt`

### Parameters
- **other**: The other value to compare against.

### Response
#### Success Response (bool)
- **bool**: `true` if `self` is greater than `other`, `false` otherwise.

## fn ge(&self, other: &Rhs) -> bool

### Description
Tests if `self` is greater than or equal to `other`. Requires `T: PartialOrd` and `E: PartialOrd`.

### Method
`ge`

### Parameters
- **other**: The other value to compare against.

### Response
#### Success Response (bool)
- **bool**: `true` if `self` is greater than or equal to `other`, `false` otherwise.
```

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

### and_then

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Calls `op` if the result is `Ok`, otherwise returns the `Err` value of `self`.

```APIDOC
## and_then

### Description
Calls `op` if the result is `Ok`, otherwise returns the `Err` value of `self`. This function can be used for control flow based on `Result` values.

### Method
`and_then<U, F>(self, op: F) -> Result<U, E> where F: FnOnce(T) -> Result<U, E>`

### Examples
```rust
// Example demonstrating and_then usage would go here if provided in source.
// For instance:
// let result = Ok(5).and_then(|x| Ok(x * 2));
// assert_eq!(result, Ok(10));
```
```

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

### unwrap

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained Ok value, consuming the self value, or panics if the value is an Err.

```APIDOC
## unwrap

### Description
Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`.
```

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

### Result::unwrap_or

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained Ok value or a provided default.

```APIDOC
## pub fn unwrap_or(self, default: T) -> T

### Description
Returns the contained `Ok` value or a provided default.

### Parameters
- **default** (T) - Required - The default value to return if self is Err.
```

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

### Rule Trait Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/enum.Rule.html

Details the trait implementations for the Rule enum, including Debug, PartialEq, Eq, and StructuralPartialEq.

```APIDOC
## Trait Implementations for Rule

### impl Debug for Rule
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

### impl PartialEq for Rule
#### fn eq(&self, other: &Rule) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.

### impl Eq for Rule

### impl StructuralPartialEq for Rule
```

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

### unwrap_or_default

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained `Ok` value or a default value if the `Result` is `Err`.

```APIDOC
## unwrap_or_default

### Description
Returns the contained `Ok` value or a default value. Consumes the `self` argument then, if `Ok`, returns the contained value, otherwise if `Err`, returns the default value for that type.

### Method
`unwrap_or_default()`

### Examples
```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse::<u32>().unwrap_or_default();
let bad_year = bad_year_from_input.parse::<u32>().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```
```

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

### Implementations for Result<&T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides methods for operating on references to Result types.

```APIDOC
## impl<T, E> Result<&T, E>

### Methods

#### `copied`
```rust
pub const fn copied(self) -> Result<T, E>
where T: Copy,
```
Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.

##### Examples
```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

#### `cloned`
```rust
pub fn cloned(self) -> Result<T, E>
where T: Clone,
```
Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.

##### Examples
```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```
```

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

### fn from_iter<I>(iter: I) -> Result<V, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Collects an iterator of Results into a single Result. If any element is an Err, it's returned immediately. Otherwise, a container with all Ok values is returned.

```APIDOC
## fn from_iter<I>(iter: I) -> Result<V, E>

### Description
Takes each element in the `Iterator`: if it is an `Err`, no further elements are taken, and the `Err` is returned. Should no `Err` occur, a container with the values of each `Result` is returned.

### Method
`from_iter`

### Parameters
- **iter** (I): An iterator where each item is a `Result<A, E>`.

### Request Example
```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    x.checked_add(1).ok_or("Overflow!")
}).collect();
assert_eq!(res, Ok(vec![2, 3]));

let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    x.checked_sub(1).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));

let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

### Response
#### Success Response (Ok(V))
- **V** (Container): A container holding the unwrapped values from the iterator if all elements were `Ok`.

#### Error Response (Err(E))
- **E**: The first `Err` value encountered in the iterator.
```

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

### Try Convert From Target Type

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Performs a conversion from type `U` to type `T`. This is a blanket implementation for `impl<T, U> TryFrom<U> for T` where `U: Into<T>`.

```rust
type Error = Infallible
```

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

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

### Rule Auto Trait Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/enum.Rule.html

Lists the auto trait implementations for the Rule enum.

```APIDOC
## Auto Trait Implementations for Rule

### impl Freeze for Rule

### impl RefUnwindSafe for Rule

### impl Send for Rule

### impl Sync for Rule

### impl Unpin for Rule

### impl UnwindSafe for Rule
```

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

### Convert Into Target Type

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Calls `U::from(self)`. This is a blanket implementation for `impl<T, U> Into<U> for T` where `U: From<T>`.

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

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

### Grammar Methods

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Grammar.html

Methods available on the Grammar struct for iterating over grammar components.

```APIDOC
## Grammar::iter

### Description
Returns an iterator over all nodes in the grammar.

### Method
Method call on Grammar instance

### Response
- **Iterator<Item = Node>** - An iterator yielding nodes defined in the grammar.

## Grammar::tokens

### Description
Returns an iterator over all tokens in the grammar.

### Method
Method call on Grammar instance

### Response
- **Iterator<Item = Token>** - An iterator yielding tokens defined in the grammar.
```

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

### Convert To String

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Converts the given value to a `String`. This is a blanket implementation for any type `T` that implements `Display`.

```rust
fn to_string(&self) -> String
```

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

### Try Convert Into Target Type

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Performs a conversion from type `T` to type `U`. This is a blanket implementation for `impl<T, U> TryInto<U> for T` where `U: TryFrom<T>`.

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

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

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

### Convert Result to Iterator

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Shows how to use IntoIterator to consume a Result, yielding the contained value if Ok or nothing if Err.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

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

### and

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`.

```APIDOC
## and

### Description
Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`. Arguments passed to `and` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `and_then`, which is lazily evaluated.

### Method
`and<U>(self, res: Result<U, E>) -> Result<U, E>`

### Examples
```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));

let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));

let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```
```

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

### Implementations for Result<Option<T>, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides methods for transposing Result types containing Options.

```APIDOC
## impl<T, E> Result<Option<T>, E>

### Methods

#### `transpose`
```rust
pub const fn transpose(self) -> Option<Result<T, E>>
```
Transposes a `Result` of an `Option` into an `Option` of a `Result`.
`Ok(None)` will be mapped to `None`. `Ok(Some(_))` and `Err(_)` will be mapped to `Some(Ok(_))` and `Some(Err(_))`.

##### Examples
```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```
```

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

### Result::or

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the provided result if the current result is Err, otherwise returns the Ok value.

```APIDOC
## pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

### Description
Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`.

### Parameters
- **res** (Result<T, F>) - Required - The result to return if self is Err.
```

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

### Convert From Self

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Error.html

Returns the argument unchanged. This is a blanket implementation for `impl<T> From<T> for T`.

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

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

### Define Token struct

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Token.html

The definition of the Token struct within the ungrammar crate.

```rust
pub struct Token(/* private fields */);
```

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

### Token Blanket Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Token.html

Shows blanket implementations for the Token struct, which are generic implementations provided by the Rust standard library for common traits.

```APIDOC
## Blanket Implementations

### impl<T> Any for T
where T: 'static + ?Sized,
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
where T: ?Sized,
#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
where T: ?Sized,
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> CloneToUninit for T
where T: Clone,
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.

### impl<T> From<T> for T
#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T
where U: From<T>,
#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T> ToOwned for T
where T: Clone,
#### type Owned = T
#### fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning.

#### fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning.

### impl<T, U> TryFrom<U> for T
where U: Into<T>,
#### type Error = Infallible
#### 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>,

```

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

### Result::unwrap_or_else

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained Ok value or computes it from a closure.

```APIDOC
## pub fn unwrap_or_else<F>(self, op: F) -> T

### Description
Returns the contained `Ok` value or computes it from a closure.

### Parameters
- **op** (FnOnce(E) -> T) - Required - The closure to compute the default value.
```

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

### impl<T, E> Hash for Result<T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides hashing capabilities for the Result type, requiring that both the Ok and Err types implement Hash.

```APIDOC
## fn hash<__H>(&self, state: &mut __H)

### Description
Feeds this value into the given `Hasher`. Requires `T: Hash` and `E: Hash`.

### Method
`hash`

### Parameters
- **state** (&mut __H): The hasher state to feed the value into.

## fn hash_slice<H>(data: &[Self], state: &mut H)

### Description
Feeds a slice of this type into the given `Hasher`. Requires `T: Hash` and `E: Hash`.

### Method
`hash_slice`

### Parameters
- **data** (&[Self]): The slice of Result values to hash.
- **state** (&mut H): The hasher state to feed the slice into.
```

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

### Implementations for Result<&mut T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides methods for operating on mutable references to Result types.

```APIDOC
## impl<T, E> Result<&mut T, E>

### Methods

#### `copied`
```rust
pub const fn copied(self) -> Result<T, E>
where T: Copy,
```
Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.

##### Examples
```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

#### `cloned`
```rust
pub fn cloned(self) -> Result<T, E>
where T: Clone,
```
Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.

##### Examples
```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```
```

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

### NodeData Trait Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.NodeData.html

Details the trait implementations available for the NodeData struct.

```APIDOC
### Debug Implementation

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.
```

```APIDOC
### Auto Trait Implementations
- Freeze
- RefUnwindSafe
- Send
- Sync
- Unpin
- UnwindSafe
```

```APIDOC
### Blanket Implementations
- **Any**
  - fn type_id(&self) -> TypeId: Gets the `TypeId` of `self`.
- **Borrow<T>**
  - fn borrow(&self) -> &T: Immutably borrows from an owned value.
- **BorrowMut<T>**
  - fn borrow_mut(&mut self) -> &mut T: Mutably borrows from an owned value.
- **From<T>**
  - fn from(t: T) -> T: Returns the argument unchanged.
- **Into<U>**
  - fn into(self) -> U: Calls `U::from(self)`.
- **TryFrom<U>**
  - type Error = Infallible
  - fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>: Performs the conversion.
- **TryInto<U>**
  - type Error = <U as TryFrom<T>>::Error
  - fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>: Performs the conversion.
```

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

### impl<T, E> Ord for Result<T, E>

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Provides total ordering for Result types, requiring that both Ok and Err types implement Ord.

```APIDOC
## fn cmp(&self, other: &Result<T, E>) -> Ordering

### Description
Compares two `Result` values and returns an `Ordering`. Requires `T: Ord` and `E: Ord`.

### Method
`cmp`

### Parameters
- **other** (&Result<T, E>): The other `Result` to compare against.

### Response
#### Success Response (Ordering)
- **Ordering**: An `Ordering` enum value (`Less`, `Equal`, `Greater`).

## fn max(self, other: Self) -> Self

### Description
Compares two `Result` values and returns the maximum. Requires `T: Ord` and `E: Ord`.

### Method
`max`

### Parameters
- **other**: The other `Result` to compare.

### Response
#### Success Response (Self)
- **Self**: The maximum of the two `Result` values.

## fn min(self, other: Self) -> Self

### Description
Compares two `Result` values and returns the minimum. Requires `T: Ord` and `E: Ord`.

### Method
`min`

### Parameters
- **other**: The other `Result` to compare.

### Response
#### Success Response (Self)
- **Self**: The minimum of the two `Result` values.

## fn clamp(self, min: Self, max: Self) -> Self

### Description
Restricts a `Result` value to be within a specified range. Requires `T: Ord` and `E: Ord`.

### Method
`clamp`

### Parameters
- **min**: The minimum allowed `Result` value.
- **max**: The maximum allowed `Result` value.

### Response
#### Success Response (Self)
- **Self**: The clamped `Result` value.
```

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

### Convert Result<&mut T, &mut E> using DerefMut

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

The `as_deref_mut` method converts a `&mut Result<T, E>` to `Result<&mut <T as DerefMut>::Target, &mut E>` by coercing the Ok variant via `DerefMut`. It allows mutable access to the contained value.

```rust
let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
```

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

### And: Combine Results

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`. Arguments are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));
```

```rust
let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));
```

```rust
let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
```

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

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

### Token Auto Trait Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/struct.Token.html

Lists the auto trait implementations for the Token struct, indicating its thread safety and memory management characteristics.

```APIDOC
## Auto Trait Implementations

### impl Freeze for Token

### impl RefUnwindSafe for Token

### impl Send for Token

### impl Sync for Token

### impl Unpin for Token

### impl UnwindSafe for Token
```

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

### Rule Blanket Implementations

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/enum.Rule.html

Details the blanket trait implementations for the Rule enum.

```APIDOC
## Blanket Implementations for Rule

### impl<T> Any for T
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> From<T> for T
#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T
#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T, U> TryFrom<U> for T
#### type Error = Infallible
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T
#### type Error = <U as TryFrom<T>>::Error
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

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

### into_err

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

Returns the contained `Err` value, but never panics. This is a nightly-only experimental API.

```APIDOC
## into_err

### Description
Returns the contained `Err` value, but never panics. Unlike `unwrap_err`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap_err` as a maintainability safeguard that will fail to compile if the ok type of the `Result` is later changed to a type that can actually occur.

### Method
`into_err()`

### Examples
```rust
fn only_bad_news() -> Result<!, String> {
    Err("Oops, it failed".into())
}

let error: String = only_bad_news().into_err();
println!("{error}");
```
```

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

### Panic with Custom Message on Error

Source: https://docs.rs/ungrammar/1.16.1/ungrammar/type.Result.html

The `expect` method unwraps the Result, returning the Ok value. If the Result is Err, it panics with a provided message and the error's description. Use this when an error is truly unrecoverable and indicates a programming error.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```
Tokens:
Raw