Pest

https://docs.rs/pest/latest/
Admin
Pest is a general-purpose parser written in Rust, focusing on accessibility, correctness, and...
Tokens:378,780
Snippets:1,714
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example: Getting Position from Start

Source: https://docs.rs/pest/latest/src/pest/position.rs.html

Shows how to get a Position at the beginning of an input string.

```rust
# use pest::Position;
let start = Position::from_start("");
assert_eq!(start.pos(), 0);
```

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

### Advanced PEEK examples with stack slicing

Source: https://docs.rs/pest/latest/index.html

Provides examples of advanced PEEK syntax, including PEEK_ALL and slicing with start and end indices. PEEK[start..end] matches bottom-to-top, while PEEK_ALL matches top-to-bottom.

```pest
fill = PUSH("c") ~ PUSH("b") ~ PUSH("a")
v = { PEEK_ALL } = { "a" ~ "b" ~ "c" }  // top to bottom
w = { PEEK[..] } = { "c" ~ "b" ~ "a" }  // bottom to top
x = { PEEK[1..2] } = { PEEK[1..-1] } = { "b" }
y = { PEEK[..-2] } = { PEEK[0..1] } = { "a" }
z = { PEEK[1..] } = { PEEK[-2..3] } = { "c" ~ "b" }
n = { PEEK[2..-2] } = { PEEK[2..1] } = { "" }
```

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

### Example: Getting Byte Position

Source: https://docs.rs/pest/latest/src/pest/position.rs.html

Illustrates how to retrieve the byte position of a Position object.

```rust
# use pest::Position;
let input = "ab";
let mut start = Position::from_start(input);

assert_eq!(start.pos(), 0);
```

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

### Create Position from Start

Source: https://docs.rs/pest/latest/pest/struct.Position.html

Creates a Position at the beginning of an input string.

```rust
let start = Position::from_start("");
assert_eq!(start.pos(), 0);
```

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

### Example: Creating and Validating Positions

Source: https://docs.rs/pest/latest/src/pest/position.rs.html

Demonstrates how to create a Position and handle cases where the position is invalid or not a UTF8 boundary.

```rust
# use pest::Position;
let cheart = '💖';
let heart = "💖";
assert_eq!(Position::new(heart, 1), None);
assert_ne!(Position::new(heart, cheart.len_utf8()), None);
```

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

### Example: Creating a Span

Source: https://docs.rs/pest/latest/src/pest/position.rs.html

Demonstrates creating a Span from two Position objects.

```rust
# use pest::Position;
let input = "ab";
let start = Position::from_start(input);
let span = start.span(&start.clone());

assert_eq!(span.start(), 0);
assert_eq!(span.end(), 0);
```

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

### Example Usage of fails_with! Macro

Source: https://docs.rs/pest/latest/pest/macro.fails_with.html

An example demonstrating how to use the `fails_with` macro to test a specific parsing failure scenario with the `AbcParser`.

```rust
fails_with! {
    parser: AbcParser,
    input: "abcdf",
    rule: Rule::a,
    positives: vec![Rule::c],
    negatives: vec![],
    pos: 4
};
```

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

### parses_to! Macro Usage Example

Source: https://docs.rs/pest/latest/pest/macro.parses_to.html

An example demonstrating how to use the `parses_to!` macro to test a parser. It specifies the parser, input, rule, and the expected token structure with byte positions.

```rust
parses_to! {
    parser: AbcParser,
    input:  "abcde",
    rule:   Rule::a,
    tokens: [
        a(0, 3, [
            b(1, 2)
        ]),
        c(4, 5)
    ]
};

```

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

### Box::try_map Example

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Demonstrates mapping a value inside a Box using a function that returns a Result. This requires the `smart_pointer_try_map` feature. The example shows converting an integer to a u32, reusing the allocation.

```rust
#![feature(smart_pointer_try_map)]

let b = Box::new(7);
let new = Box::try_map(b, u32::try_from).unwrap();
assert_eq!(*new, 7);
```

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

### Get the start Position of a Span

Source: https://docs.rs/pest/latest/pest/struct.Span.html

Returns the start Position of the Span. This Position can be used for further span manipulations or comparisons.

```rust
let input = "ab";
let start = Position::from_start(input);
let end = start.clone();
let span = start.clone().span(&end);

assert_eq!(span.start_pos(), start);
```

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

### Get Start Line and Column

Source: https://docs.rs/pest/latest/src/pest/error.rs.html

Retrieves the starting line and column number from a LineColLocation. Handles both single positions and spans.

```rust
    fn start(&self) -> (usize, usize) {
        match self.line_col {
            LineColLocation::Pos(line_col) => line_col,
            LineColLocation::Span(start_line_col, _) => start_line_col,
        }
    }
```

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

### Example: Calculating Line and Column

Source: https://docs.rs/pest/latest/src/pest/position.rs.html

Shows how to calculate the line and column number for a given position using a parser state.

```rust
# use pest;
# #[allow(non_camel_case_types)]
# #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
# enum Rule {}

let input = "\na";
let mut state: Box<pest::ParserState<'_, Rule>> = pest::ParserState::new(input);
let mut result = state.match_string("\na");
assert!(result.is_ok());
assert_eq!(result.unwrap().position().line_col(), (2, 2));
```

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

### Box::from_raw Example

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Demonstrates how to reconstruct a Box from a raw pointer, which is useful for managing memory after using Box::into_raw.

```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };

```

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

### Get the start position of a Span

Source: https://docs.rs/pest/latest/pest/struct.Span.html

Returns the start byte position of the Span as a usize. Used to determine the beginning of the spanned text.

```rust
let input = "ab";
let start = Position::from_start(input);
let end = start.clone();
let span = start.span(&end);

assert_eq!(span.start(), 0);
```

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

### Get the start byte position of a Span

Source: https://docs.rs/pest/latest/src/pest/span.rs.html

Returns the starting byte index of the Span within the input string. This is a direct byte offset.

```rust
pub fn start(&self) -> usize {
    self.start
}
```

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

### Example: Using Pairs::find_first_tagged()

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pairs.html

Illustrates finding the first Pair tagged with a specific label, demonstrating how to identify branches in a parsed structure.

```rust
use pest::{state, ParseResult, ParserState};
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
enum Rule {
    number, // 0..9
    add,    // num + num
    mul,    // num * num
}
fn mark_branch(
    state: Box<ParserState<'_, Rule>>,
) -> ParseResult<Box<ParserState<'_, Rule>>> {
    expr(state, Rule::mul, "*")
        .and_then(|state| state.tag_node("mul"))
        .or_else(|state| expr(state, Rule::add, "+"))
        .and_then(|state| state.tag_node("add"))
}
fn expr<'a>(
    state: Box<ParserState<'a, Rule>>,
    r: Rule,
    o: &'static str,
) -> ParseResult<Box<ParserState<'a, Rule>>> {
    state.rule(r, |state| {
        state.sequence(|state| {
            number(state)
                .and_then(|state| state.tag_node("lhs"))
                .and_then(|state| state.match_string(o))
                .and_then(number)
                .and_then(|state| state.tag_node("rhs"))
        })
    })
}
fn number(state: Box<ParserState<'_, Rule>>) -> ParseResult<Box<ParserState<'_, Rule>>> {
    state.rule(Rule::number, |state| state.match_range('0'..'9'))
}
let input = "1+2";
let pairs = state(input, mark_branch).unwrap();
assert_eq!(pairs.find_first_tagged("add").unwrap().as_rule(), Rule::add);
assert_eq!(pairs.find_first_tagged("mul"), None);
```

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

### Comment Example

Source: https://docs.rs/pest/latest/index.html

Comments in pest grammars start with `//` and extend to the end of the line.

```pest
// a comment
```

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

### Box::from_raw_in Example (Manual Creation)

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Illustrates manually creating a Box<T, A> from a raw pointer and allocator, using `allocator_api` and `slice_ptr_get` features. This involves allocating memory, writing a value, and then constructing the Box.

```rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
```

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

### Get Pair Span

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pair.html

Returns the Span defined by the Pair without consuming it. This provides access to the start and end positions of the matched text.

```Rust
enum Rule {
    ab
}

let input = "ab";
let pair = pest::state(input, |state| {
    // generating Token pair with Rule::ab ...
}).unwrap().next().unwrap();

assert_eq!(pair.as_span().as_str(), "ab");
```

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

### Pratt Parser Expression Parsing Example

Source: https://docs.rs/pest/latest/src/pest/pratt_parser.rs.html

Demonstrates how to parse an expression using a PrattParser by mapping primary expressions, prefix, postfix, and infix operators. This setup is useful for arithmetic expressions or similar structured data.

```Rust
# use pest::{iterators::Pairs, pratt_parser::PrattParser};
# #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
# enum Rule { program, expr, int, add, mul, sub, div, pow, fac, neg }
fn parse_expr(pairs: Pairs<Rule>, pratt: &PrattParser<Rule>) -> i32 {
    pratt
        .map_primary(|primary| match primary.as_rule() {
            Rule::int  => primary.as_str().parse().unwrap(),
            Rule::expr => parse_expr(primary.into_inner(), pratt), // from "(" ~ expr ~ ")"
            _          => unreachable!(),
        })
        .map_prefix(|op, rhs| match op.as_rule() {
            Rule::neg  => -rhs,
            _          => unreachable!(),
        })
        .map_postfix(|lhs, op| match op.as_rule() {
            Rule::fac  => (1..lhs+1).product(),
            _          => unreachable!(),
        })
        .map_infix(|lhs, op, rhs| match op.as_rule() {
            Rule::add  => lhs + rhs,
            Rule::sub  => lhs - rhs,
            Rule::mul  => lhs * rhs,
            Rule::div  => lhs / rhs,
            Rule::pow  => (1..rhs+1).map(|_| lhs).product(),
            _          => unreachable!(),
        })
        .parse(pairs)
}
```

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

### Box::from_raw_in Example (Recreate)

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Demonstrates recreating a Box<T, A> from a raw pointer and allocator, using the `allocator_api` feature. This is useful when a Box has been converted to a raw pointer and needs to be reconstructed.

```rust
#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(5, System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

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

### Span Sub-slicing with `get`

Source: https://docs.rs/pest/latest/src/pest/span.rs.html

Demonstrates how to extract sub-spans using the `get` method, including valid and invalid ranges.

```rust
    #[test]
    fn get() {
        let input = "abc123abc";
        let span = Span::new(input, 3, input.len()).unwrap();
        assert_eq!(span.as_str(), "123abc");
        assert_eq!(span.input, input);

        let span1 = span.get(..=2);
        assert!(span1.is_some());
        assert_eq!(span1.unwrap().input, input);
        assert_eq!(span1.unwrap().as_str(), "123");

        let span2 = span.get(..);
        assert!(span2.is_some());
        assert_eq!(span2.unwrap().input, input);
        assert_eq!(span2.unwrap().as_str(), "123abc");

        let span3 = span.get(3..);
        assert!(span3.is_some());
        assert_eq!(span3.unwrap().input, input);
        assert_eq!(span3.unwrap().as_str(), "abc");

        let span4 = span.get(0..0);
        assert!(span4.is_some());
        assert_eq!(span4.unwrap().input, input);
        assert_eq!(span4.unwrap().as_str(), "");
    }

    #[test]
    fn get_fails() {
        let input = "abc";
        let span = Span::new(input, 0, input.len()).unwrap();

        let span1 = span.get(0..100);
        assert!(span1.is_none());

        let span2 = span.get(100..200);
        assert!(span2.is_none());
    }
```

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

### Box::into_raw with Manual Cleanup Example

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Shows how to manually clean up memory after converting a Box into a raw pointer using Box::into_raw.

```rust
use std::alloc::{dealloc, Layout};
use std::ptr;

let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    ptr::drop_in_place(ptr);
    dealloc(ptr as *mut u8, Layout::new::<String>());
}

```

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

### Check for Start of Input in ParserState

Source: https://docs.rs/pest/latest/src/pest/parser_state.rs.html

Checks if the parser is at the beginning of the input. Returns Ok if at the start, Err otherwise.

```Rust
use pest;
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
enum Rule {}

let input = "ab";
let mut state: Box<pest::ParserState<'_, Rule>> = pest::ParserState::new(input);
let mut result = state.start_of_input();
assert!(result.is_ok());

state = pest::ParserState::new(input);
state = state.match_string("ab").unwrap();
result = state.start_of_input();
assert!(result.is_err());
```

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

### Get Pair Span (Deprecated)

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pair.html

Deprecated method to get the Span defined by the Pair, consuming it. Use `as_span` instead.

```Rust
enum Rule {
    ab
}

let input = "ab";
let pair = pest::state(input, |state| {
    // generating Token pair with Rule::ab ...
}).unwrap().next().unwrap();

assert_eq!(pair.into_span().as_str(), "ab");
```

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

### Box::from_non_null with Manual Allocation Example (Nightly)

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Demonstrates creating a Box from a NonNull pointer obtained via manual memory allocation, using nightly Rust features.

```rust
#![feature(box_vec_non_null)]

use std::alloc::{alloc, Layout};
use std::ptr::NonNull;

unsafe {
    let non_null = NonNull::new(alloc(Layout::new::<i32>()).cast::<i32>())
        .expect("allocation failed");
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null(non_null);
}

```

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

### Box::from_non_null_in Example (Manual Creation)

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Demonstrates manually creating a Box<T, A> from a NonNull pointer and allocator, utilizing `allocator_api`, `box_vec_non_null`, and `slice_ptr_get` features. It involves allocating memory, writing a value, and then forming the Box.

```rust
#![feature(allocator_api, box_vec_non_null, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let non_null = System.allocate(Layout::new::<i32>())?.cast::<i32>();
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null_in(non_null, System);
}
```

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

### Unicode Trie ID Start Constant

Source: https://docs.rs/pest/latest/src/pest/unicode/binary.rs.html

Defines the `ID_START` constant, which is a `TrieSet` used for identifying the start of Unicode identifiers.

```rust
pub const ID_START: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet {
  tree1_level1: &[
    0, 0x7FFFFFE07FFFFFE, 0x420040000000000, 0xFF7FFFFFFF7FFFFF,
    0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
    0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
    0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, 0, 0xBCDF000000000000,
    0xFFFFFFFBFFFFD740, 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
    0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF,
    0xFFFEFFFFFFFFFFFF, 0xFFFFFFFF027FFFFF, 0x1FF, 0x787FFFFFF0000,
    0xFFFFFFFF00000000, 0xFFFEC000000007FF, 0xFFFFFFFFFFFFFFFF,
    0x9C00C060002FFFFF, 0xFFFFFFFD0000, 0xFFFFFFFFFFFFE000, 0x2003FFFFFFFFF,
    0x43007FFFFFFFC00,
  ],
  tree2_level1: &[
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
    21, 22, 23, 24, 23, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 35, 35,
    35, 35, 36, 37, 38, 39, 40, 41, 42, 43, 35, 35, 35, 35, 35, 35, 35, 35,
    44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 3, 58, 59, 60, 30,
    61, 62, 63, 64, 65, 66, 67, 68, 35, 35, 35, 30, 35, 35, 35, 35, 69, 70,
    71, 72, 30, 73, 74, 30, 75, 76, 77, 30, 30, 30, 30, 30, 30, 30, 30, 30,
    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 35, 35, 35, 78,
    79, 80, 81, 82, 30, 30, 30, 30, 30, 30, 30, 30, 83, 43, 84, 85, 86, 35,
  ],
  tree3_level3: &[
    0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0,
    0x1FFFFFFFFFFFFF, 0x2000000000000000, 0xFFFFFFFF1FFFFFFF, 0x10001FFFF,
    0xFFFFE000FFFFFFFF, 0x7FFFFFFFFFF07FF, 0xFFFFFFFF3FFFFFFF, 0x3EFF0F,
    0xFFFF03FF3FFFFFFF, 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF,
    0xF7FF000FFFFFFFFF, 0x1BFBFFFBFFB7F7FF, 0xFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFF,
    0xFF003FFFFF, 0x7FDFFFFFFFFFFBF, 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF,
    0x7FFFFFFF, 0x37FFFF00000000, 0x3FFFFFF003FFFFF, 0x3FFFFFF,
    0xC0FFFFFFFFFFFFFF, 0x873FFFFFFEEFF06F, 0x1FFFFFFF00000000, 0x1FFFFFFF,
    0x7FFFFFFEFF, 0x3FFFFFFFFFFFFF, 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF,
    0x7FFFFFFFFFFFF, 0x3FF00FFFFFFFFFF, 0xFFFFBE3FFFFFFFFF, 0x3F,
    0x31BFFFFFFFFFF, 0xFC000000000000FC, 0xFFFF00801FFFFFFF,
    0xFFFF00000001FFFF, 0xFFFF00000000003F, 0x7FFFFF0000001F,
    0x803FFFC00000007F, 0x3FF01FFFFFF0004, 0xFFDFFFFFFFFFFFFF,
    0x4FFFFFFFFF00F0, 0x17FFDE1F, 0xC0FFFFFFFFFBFFFF, 0x3, 0xFFFF01FFBFFFBD7F,
    0x3FF07FFFFFFFFFF, 0xFBEDFDFFFFF99FEF, 0x1F1FCFE081399F,
    0xFFBFFFFFFFFF4BFF, 0x6000FF7A5, 0x3C3FF07FF, 0x3FF00BF,
    0xFF3FFFFFFFFFFFFF, 0x3F000001, 0x3FF0011, 0x1FFFFFFFFFFFFFF, 0xFFFFF03FF,
    0x3FF0FFFE7FFFFFF, 0x7F, 0xFFFFFFFF00000000, 0x800003FFFFFFFFFF,
    0xF9BFFFFFFF6FF27F, 0x3FF000F, 0xFFFFFCFF00000000, 0x1BFCFFFFFF,
    0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0080, 0xFFFF000023FFFFFF, 0xFF00000000,
    0x3FF0001FFFFFFFF, 0xFF7FFFFFFFFFFDFF, 0xFFFC000003FF0001,
    0x7FFEFFFFFCFFFF, 0xB47FFFFFFFFFFB7F, 0xFFFFFDBF03FF00FF,
    0xFFFF03FF01FB7FFF, 0x3FF0FFFFFFF, 0x7FFFFF00000000, 0xC7FFFFFFFFFDFFFF,
    0x7FF0007, 0x1000000000000, 0x7FFFFFFFFFFF, 0xF, 0xFFFFFFFFFFFF0000,
    0x1FFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0xFFFFFFFF003FFFFF, 0x3FFFFFFFFFFFFFF,
    0xFFFF03FF7FFFFFFF, 0x1F3FFFFFFF03FF, 0xE0FFFFF803FF000F, 0xFFFF,
    0x3FF1FFFFFFFFFFF, 0xF9FFFFFF00000000, 0xFFFFF, 0xFFFFFFFFFFFF87FF,
    0xFFFF80FF, 0x7F001B00000000, 0x80000000003FFFFF, 0x6FEF000000000000,
    0x40007FFFFFFFF, 0xFFFF00F000270000, 0xFFFFFFFFFFFFFFF,
    0x1FFF07FFFFFFFFFF, 0x63FF01FF, 0x3FF000000000000, 0xFFFF3FFFFFFFFFFF,
    0xF807E3E000000000, 0x3C0000000FE7, 0x1C, 0xFFFFFFFFFFDFFFFF,
    0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF,
    0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD,
    0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF,
    0xFFFFFFFFFFFFCFF7, 0xF87FFFFFFFFFFFFF, 0x201FFFFFFFFFFF, 0xFFFEF8000010,
    0x7E07FFFFFFF, 0xFFFF07DBF9FFFF7F, 0x3FFFFFFFFFFF, 0x8000,
    0x3FFF1FFFFFFFFFFF, 0x43FF, 0x7FFFFFFF0000, 0x3FFFFFFFFFF0000,
    0x7FFFFFFFFFF0000, 0xC03FFFFF7FFFFFFF, 0x7FFF6F7F00000000, 0x7F001F,
    0x3FF0FFF, 0xAF7FE96FFFFFFEF, 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF,
    0xFFFFFFFF, 0xFFFF0001FFFFFFFF, 0x3FFFFFFF, 0xFFFFFFFFFFFF07FF,
  ],
};

```

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

### Split Span into Start and End Positions

Source: https://docs.rs/pest/latest/src/pest/span.rs.html

Shows how to split a span into its start and end positions using the `split` method.

```rust
fn split() {
        let input = "a";
        let start = position::Position::from_start(input);
        let mut end = start;

        assert!(end.skip(1));

        let span = start.clone().span(&end.clone());

        assert_eq!(span.split(), (start, end));
    }
```

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

### Box::from_raw with Manual Allocation Example

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Illustrates creating a Box from a raw pointer obtained via manual memory allocation using std::alloc.

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}

```

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

### Example: Using Pairs::get_input() and Pairs::as_str()

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pairs.html

Illustrates the difference between `get_input()` which returns the original input string, and `as_str()` which returns the slice covered by the Pairs.

```rust
enum Rule {
    a,
    b
}

// Example: Get input string from Pairs

let input = "a b";
let pairs = pest::state(input, |state| {
    // generating Token pairs with Rule::a and Rule::b ...
}).unwrap();

assert_eq!(pairs.as_str(), "a b");
assert_eq!(input, pairs.get_input());
```

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

### Silent Rule Example

Source: https://docs.rs/pest/latest/index.html

Silent rules (`_`) do not create token pairs and are not error-reported. This example shows how a silent rule affects token generation.

```pest
a = _ { "a" }
b =  { a ~ "b" }
```

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

### CloneToUninit Implementation (Nightly)

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pair.html

An experimental nightly-only API for performing copy-assignment to uninitialized memory.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

### Parameters
- **dest** (*mut u8) - Required - A mutable pointer to the destination memory.

### Safety
This function is unsafe and requires `T: Clone`. The caller must ensure that `dest` is a valid, writable pointer to enough memory to hold a `T`.
```

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

### Pratt Parser Construction Example

Source: https://docs.rs/pest/latest/src/pest/pratt_parser.rs.html

Demonstrates how to build a `PrattParser` instance by chaining operator definitions with specified precedences and associativities.

```Rust
# use pest::pratt_parser::{Assoc, Op, PrattParser};
# #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
# enum Rule { program, expr, int, add, mul, sub, div, pow, fac, neg }
let pratt = 
    PrattParser::new()
        .op(Op::infix(Rule::add, Assoc::Left) | Op::infix(Rule::sub, Assoc::Left))
        .op(Op::infix(Rule::mul, Assoc::Left) | Op::infix(Rule::div, Assoc::Left))
        .op(Op::infix(Rule::pow, Assoc::Right))
        .op(Op::prefix(Rule::neg))

```

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

### Unicode Binary Data Structure Example

Source: https://docs.rs/pest/latest/src/pest/unicode/binary.rs.html

Example of a binary data structure, likely for Unicode character properties or similar data. This specific array is named 'tree3_level3'.

```rust
tree3_level3: &[
    0, 0x2000000000000000, 0x100000000, 0x7C0000000000000, 0x870000000000F06E,
    0x6000000000, 0xF000000000, 0x3E0000000000, 0x180000000000,
    0xFC00000000000000, 0x1FFC0, 0x3C, 0xFF00000000000002, 0x801900000000007F,
    0x678000000000003, 0x4, 0x1FEF8000000007, 0x8000000000000,
    0x7FC0000000000003, 0x9E01, 0x40F3800000000000, 0x2, 0x7F880000000,
    0x5800000000000003, 0x1F1FC000802001, 0xF900000000000000, 0x60005C3A5,
    0xFF00000000000000, 0x4000005C, 0xA5F9000000000000, 0xD,
    0xB03C800000000000, 0x30000001, 0xA7F8000000000000, 0x1, 0xFF280000000000,
    0xFBCA0000000, 0x6FF800000000000, 0x7801000000000000, 0x8, 0x10CF00000,
    0x79F80000000007FE, 0xE7E0080, 0x37FFC00, 0x5D00000000,
    0xBF7F000000000000, 0x6DFCFFFFFC0000, 0xB47E000000000000, 0xBF, 0xA30000,
    0x18000000000000, 0x7C0000000000003, 0x4000007, 0x3FFF81, 0xE3FFC0000000,
    0x1F000000000000, 0x7F000000000000, 0x8000, 0x78000, 0x3001000000000,
    0x60000000, 0xFFFF3FFFFFFFFFFF, 0x7F, 0xF807E3E000000000, 0x3C0000000FE7,
    0x1C, 0xF87FFFFFFFFFFFFF, 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F,
    0x400000000000, 0xF00000000000, 0xC00000000000, 0x20C04800000000,
    0x7F0000, 0x7F0, 0xFFFFFFFF00000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF,
  ],
};

```

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

### Box::new_uninit

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Constructs a new box with uninitialized contents.

```APIDOC
## pub fn new_uninit() -> Box<MaybeUninit<T>>

### Description
Constructs a new box with uninitialized contents.

### Method
Associated function (called as `Box::new_uninit()`)

### Examples
```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```
```

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

### Example Usage of Pest Parser State

Source: https://docs.rs/pest/latest/src/pest/parser_state.rs.html

Demonstrates how to use the `pest::state` function to parse input using a defined rule. This example shows basic parsing of a single character rule.

```rust
# use pest;
# #[allow(non_camel_case_types)]
# #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
# enum Rule {
#     a
# }

let input = "a";
let pairs: Vec<_> = pest::state(input, |state| {
    state.rule(Rule::a, |s| Ok(s))
}).unwrap().collect();

assert_eq!(pairs.len(), 1);
```

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

### Box::into_raw Equivalent Manual Cleanup Example

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Provides an alternative manual cleanup method for Box::into_raw by converting the raw pointer back to a Box and letting its destructor handle cleanup.

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    drop(Box::from_raw(ptr));
}

```

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

### Example: Using Pairs::as_str()

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pairs.html

Demonstrates how to use the `as_str()` method to capture the full input string covered by a Pairs iterator.

```rust
enum Rule {
    a,
    b
}

let input = "a b";
let pairs = pest::state(input, |state| {
    // generating Token pairs with Rule::a and Rule::b ...
}).unwrap();

assert_eq!(pairs.as_str(), "a b");
```

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

### new_uninit_in

Source: https://docs.rs/pest/latest/pest/error/type.IsWhitespaceFn.html

Constructs a new Box with uninitialized contents in the provided allocator. This is a nightly-only experimental API.

```APIDOC
## pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>

### Description
Constructs a new box with uninitialized contents in the provided allocator.

### Method
`new_uninit_in`

### Parameters
#### Path Parameters
- **alloc** (A) - Required - The allocator to use for the Box.

### Response
#### Success Response
- **Box<MaybeUninit<T>, A>** - A new Box with uninitialized contents allocated using the provided allocator.

### Examples
```rust
#![feature(allocator_api)]

use std::alloc::System;

let mut five = Box::<u32, _>::new_uninit_in(System);
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```
```

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

### Span::start_pos

Source: https://docs.rs/pest/latest/pest/struct.Span.html

Returns the starting `Position` of the span.

```APIDOC
## Span::start_pos

### Description
Returns the `Span`’s start `Position`.

### Method
`pub fn start_pos(&self) -> Position<'i>`

### Response
* `Position<'i>`: The starting `Position` of the span.

### Examples
```
let input = "ab";
let start = Position::from_start(input);
let end = start.clone();
let span = start.clone().span(&end);

assert_eq!(span.start_pos(), start);
```
```

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

### Pest Expression Examples: Identifier Matching

Source: https://docs.rs/pest/latest/pest

Demonstrates how different Pest expression syntaxes affect input matching, particularly for identifiers. The first example shows a failing match due to incorrect sequencing, while the second illustrates successful repeated matching.

```pest
identifier = @{ "a" ~ ("b"|("_")*) ~ "b" }
// matches:      a     b_bb_b       nothing -> error!
```

```pest
identifier = @{ "a" ~ ("_"* ~ "b")* }
// matches:      a     b, _bb, _b   in three repetitions
```

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

### Match String with ParserState

Source: https://docs.rs/pest/latest/pest/struct.ParserState.html

Demonstrates matching a specific string against the current parser state. Includes examples for successful matches and mismatches, checking the resulting position.

```rust
enum Rule {}

let input = "ab";
let mut state: Box<pest::ParserState<'_, Rule>> = pest::ParserState::new(input);
let mut result = state.match_string("ab");
assert!(result.is_ok());
assert_eq!(result.unwrap().position().pos(), 2);

state = pest::ParserState::new(input);
result = state.match_string("ac");
assert!(result.is_err());
assert_eq!(result.unwrap_err().position().pos(), 0);
```

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

### Create a new Stack

Source: https://docs.rs/pest/latest/pest/struct.Stack.html

Initializes a new instance of the Stack.

```rust
pub fn new() -> Self
```

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

### Any Implementation

Source: https://docs.rs/pest/latest/pest/iterators/struct.Pair.html

Provides the `type_id` method to get the `TypeId` of an instance.

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

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The unique identifier for the type of `self`.
```

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

### Stack Snapshot and Restore with Empty Stack

Source: https://docs.rs/pest/latest/src/pest/stack.rs.html

Demonstrates taking a snapshot of an empty stack, pushing an element, and then restoring to the empty state.

```rust
    #[test]
    fn snapshot_with_empty() {
        let mut stack = Stack::new();

        stack.snapshot();
        // []
        assert!(stack.is_empty());
        // [0]
        stack.push(0);
        stack.restore();
        assert!(stack.is_empty());
    }
```

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

### ParserState::get_parse_attempts

Source: https://docs.rs/pest/latest/pest/struct.ParserState.html

Get all parse attempts after process of parsing is finished.

```APIDOC
## ParserState::get_parse_attempts

### Description
Get all parse attempts after process of parsing is finished.

### Method

`pub fn get_parse_attempts(&self) -> &ParseAttempts<R>`

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example usage requires a completed parsing process.
// let attempts = state.get_parse_attempts();
```

### Response
#### Success Response (200)
- **&ParseAttempts<R>** - A reference to the ParseAttempts collection.

#### Response Example
```rust
// Example response is implicit in the example usage.
```
```
Tokens:
Raw