Winnow

https://github.com/winnow-rs/winnow
Admin
Winnow is a byte-oriented, zero-copy parser combinator library for Rust, designed to make writing...
Tokens:33,515
Snippets:449
Trust Score:4.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize StrContext

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Example of creating label and expected context instances.

```rust
use winnow::error::StrContext;

let label = StrContext::Label("number");
let expected = StrContext::Expected(
    winnow::error::StrContextValue::Description("digit")
);
```

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

### Create Error from Input Example

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Demonstrates initializing a ContextError from an input string.

```rust
use winnow::error::{ParserError, ContextError};

let input = "hello";
let err = ContextError::from_input(&input);
// err now tracks position at "hello"
```

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

### SliceLen Usage Example

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Shows length calculation for strings, slices, and characters.

```rust
use winnow::stream::SliceLen;

assert_eq!("hello".slice_len(), 5);
assert_eq!([1, 2, 3][..].slice_len(), 3);
assert_eq!('a'.slice_len(), 1);
```

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

### Parse Next Method Usage

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Example demonstrating how parse_next advances the input stream.

```rust
use winnow::prelude::*;
use winnow::ascii::alpha1;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    alpha1.parse_next(input)
}

let mut input = "hello world";
assert_eq!(parser(&mut input), Ok("hello"));
assert_eq!(input, " world");
```

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

### Check Backtrack Status Example

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Demonstrates checking if a ContextError is recoverable.

```rust
use winnow::error::{ParserError, ContextError};

let input = "hello";
let err = ContextError::from_input(&input);
assert!(err.is_backtrack());
```

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

### Parse Method Usage

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Example demonstrating full input parsing and error handling for trailing input.

```rust
use winnow::prelude::*;
use winnow::ascii::dec_uint;

let parser = dec_uint::<_, winnow::error::ContextError>;
assert_eq!(parser.parse("42"), Ok(42u32));
assert!(parser.parse("42 extra").is_err());  // trailing input
```

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

### Parse Iter Method Usage

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Example demonstrating how to iterate over results from a parser until the input is consumed.

```rust
use winnow::prelude::*;
use winnow::ascii::dec_uint;
use winnow::combinator::terminated;
use winnow::ascii::newline;
use winnow::combinator::opt;

fn number(input: &mut &str) -> winnow::ModalResult<u32> {
    terminated(dec_uint, opt(newline)).parse_next(input)
}

let input = "10\n20\n30";
let numbers: Vec<u32> = number.parse_iter(input)
    .map(|r| r.unwrap()).collect();
assert_eq!(numbers, vec![10, 20, 30]);
```

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

### StreamIsPartial Usage Example

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Demonstrates checking partial status for full and partial input types.

```rust
use winnow::prelude::*;
use winnow::Partial;

let full: &str = "hello";
let partial = Partial::new("hello");

assert!(!full.is_partial());
assert!(partial.is_partial());
```

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

### Implement a Parser with ModalResult

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Example of a parser function returning the ModalResult type alias.

```rust
use winnow::prelude::*;
use winnow::error::ContextError;

fn my_parser(input: &mut &str) -> winnow::ModalResult<&str> {
    winnow::ascii::alpha1.parse_next(input)
}
```

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

### offset_at

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Get the offset for the number of tokens into the stream.

```APIDOC
## fn offset_at(&self, tokens: usize) -> Result<usize, Needed>

### Description
Get the offset for the number of tokens into the stream.

### Parameters
- **tokens** (usize) - Required - Number of tokens to advance

### Return Type
Result<usize, Needed> - Byte offset or needed amount.
```

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

### Check for Incomplete Errors

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Method signature and usage example for checking if an error mode is incomplete.

```rust
pub fn is_incomplete(&self) -> bool
```

```rust
use winnow::error::ErrMode;
use winnow::stream::Needed;

let incomplete: ErrMode<()> = ErrMode::Incomplete(Needed::Unknown);
assert!(incomplete.is_incomplete());

let backtrack: ErrMode<()> = ErrMode::Backtrack(());
assert!(!backtrack.is_incomplete());
```

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

### Handle ParseError

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Example of matching a result to extract error position information.

```rust
use winnow::prelude::*;
use winnow::error::ParseError;

let result = winnow::ascii::alpha1::<&str, _>
    .parse("123abc");

match result {
    Err(ParseError { input, offset, .. }) => {
        println!("Failed at offset {}: {}", offset, input);
    }
    Ok(_) => {}
}
```

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

### Handle Complete Parse Failure

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/errors.md

Demonstrates the error result when a parser fails to match the input at the start.

```rust
use winnow::prelude::*;

let result = winnow::ascii::alpha1::<&str, _>
    .parse("123");  // Fails immediately

// Returns: Err(ParseError { input: "123", offset: 0, inner: ... })
```

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

### peek_token

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Get the next token without advancing the stream.

```APIDOC
## fn peek_token(&self) -> Option<Self::Token>

### Description
Get the next token without advancing the stream.

### Return Type
Option<Self::Token> - Next token or None at EOF.
```

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

### peek_slice

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Get a slice without advancing the stream.

```APIDOC
## fn peek_slice(&self, offset: usize) -> Self::Slice

### Description
Get a slice without advancing the stream.

### Parameters
- **offset** (usize) - Required - Number of bytes to peek

### Return Type
Self::Slice - The peeked slice.
```

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

### Parse Little-Endian Unsigned Integer

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Example of parsing a little-endian unsigned 32-bit integer.

```rust
use winnow::prelude::*;
use winnow::binary::le_u32;

let bytes = &[0x78, 0x56, 0x34, 0x12][..];
assert_eq!(le_u32::<_, winnow::error::ContextError>
    .parse_peek(bytes), Ok((&[][..], 0x12345678u32)));
```

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

### Convert Cut to Backtrack

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Method signature and usage example for converting a cut error into a backtrack error.

```rust
pub fn backtrack(self) -> Self
```

```rust
use winnow::error::ErrMode;

let cut: ErrMode<i32> = ErrMode::Cut(1);
let backtrack = cut.backtrack();
assert!(matches!(backtrack, ErrMode::Backtrack(_)));
```

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

### Parse Little-Endian Signed Integer

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Example of parsing a little-endian signed 32-bit integer.

```rust
use winnow::prelude::*;
use winnow::binary::le_i32;

let bytes = &[0xFF, 0xFF, 0xFF, 0xFF][..];
assert_eq!(le_i32::<_, winnow::error::ContextError>
    .parse_peek(bytes), Ok((&[][..], -1i32)));
```

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

### Parse Big-Endian Unsigned Integer

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Example of parsing a big-endian unsigned 32-bit integer.

```rust
use winnow::prelude::*;
use winnow::binary::be_u32;

let bytes = &[0x12, 0x34, 0x56, 0x78][..];
assert_eq!(be_u32::<_, winnow::error::ContextError>
    .parse_peek(bytes), Ok((&[][..], 0x12345678u32)));
```

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

### Parse Big-Endian Signed Integer

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Example of parsing a big-endian signed 32-bit integer.

```rust
use winnow::prelude::*;
use winnow::binary::be_i32;

let bytes = &[0xFF, 0xFF, 0xFF, 0xFF][..];
assert_eq!(be_i32::<_, winnow::error::ContextError>
    .parse_peek(bytes), Ok((&[][..], -1i32)));
```

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

### Parse Unsigned Integer with Configurable Endianness

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Example of parsing a little-endian unsigned 32-bit integer.

```rust
use winnow::prelude::*;
use winnow::binary::{u32, Endianness};

fn parser(input: &mut &[u8]) -> winnow::ModalResult<u32> {
    u32(Endianness::Little).parse_next(input)
}

let bytes = &[0x42, 0x00, 0x00, 0x00][..];
assert_eq!(parser.parse_peek(bytes), Ok((&[][..], 0x42u32)));
```

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

### Convert Backtrack to Cut

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Method signature and usage example for converting a backtrack error into a cut error.

```rust
pub fn cut(self) -> Self
```

```rust
use winnow::error::ErrMode;

let backtrack: ErrMode<i32> = ErrMode::Backtrack(1);
let cut = backtrack.cut();
assert!(matches!(cut, ErrMode::Cut(_)));
```

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

### Parse Signed Integer with Configurable Endianness

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Example of parsing a big-endian signed 32-bit integer.

```rust
use winnow::prelude::*;
use winnow::binary::{i32, Endianness};

fn parser(input: &mut &[u8]) -> winnow::ModalResult<i32> {
    i32(Endianness::Big).parse_next(input)
}

let bytes = &[0x00, 0x00, 0x00, 0x42][..];
assert_eq!(parser.parse_peek(bytes), Ok((&[][..], 0x42i32)));
```

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

### Configure Full Features with Debugging

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Includes all standard features, SIMD optimizations, and debugging capabilities via trace().

```toml
[dependencies]
winnow = { version = "1.0", features = ["debug", "simd"] }
```

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

### Configure Release Profile

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Optimizes release builds with abort-on-panic, single codegen units, and link-time optimization.

```toml
[profile.release]
panic = "abort"
codegen-units = 1
lto = true
```

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

### Configure Pre-Release Automation

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Automate changelog updates and version bumping during the release process using package metadata.

```toml
[package.metadata.release]
pre-release-replacements = [
  {file="CHANGELOG.md", search="Unreleased", replace="{{version}}", min=1},
  {file="CHANGELOG.md", search="\\.\\.\\.HEAD", replace="...{{tag_name}}", exactly=1},
  {file="CHANGELOG.md", search="ReleaseDate", replace="{{date}}", min=1},
  {file="CHANGELOG.md", search="<!-- next-header -->", replace="<!-- next-header -->\n## [Unreleased] - ReleaseDate\n", exactly=1},
  {file="CHANGELOG.md", search="<!-- next-url -->", replace="<!-- next-url -->\n[Unreleased]: https://github.com/winnow-rs/winnow/compare/{{tag_name}}...HEAD", exactly=1},
  {file="src/lib.rs", search="blob/v.+\\..+\\..+/CHANGELOG.md", replace="blob/v{{version}}/CHANGELOG.md", exactly=1},
]
```

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

### Configure docs.rs metadata

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Sets features and rustdoc arguments for documentation generation on docs.rs.

```toml
[package.metadata.docs.rs]
features = ["unstable-doc"]
rustdoc-args = ["--generate-link-to-definition"]
```

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

### Get EOF offset

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Returns the byte offset representing the end of the input stream.

```rust
use winnow::stream::Stream;

let input = "hello";
assert_eq!(input.eof_offset(), 5);
```

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

### Configure Development Profile

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Sets panic behavior to abort for development builds.

```toml
[profile.dev]
panic = "abort"
```

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

### Configure alloc feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable heap allocation support for types like Vec and String.

```toml
alloc = []
```

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

### Configure Minimal Size Dependency

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Use this configuration for embedded systems requiring no standard library and no heap allocation.

```toml
[dependencies]
winnow = { version = "1.0", default-features = false }
```

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

### empty

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Succeeds, consuming no input.

```APIDOC
## empty

### Description
Succeed, consuming no input. Returns the default value for the output type.

### Signature
`pub fn empty<I, O: Default, E>(_: &mut I) -> Result<O, E>`
```

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

### Configure unstable-doc feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable all features for documentation generation purposes.

```toml
unstable-doc = ["alloc", "std", "ascii", "binary", "simd", "unstable-recover"]
```

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

### Configure std feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable standard library support for full heap allocation and advanced stream types.

```toml
std = ["alloc", "memchr?/std"]
```

```toml
[dependencies]
winnow = { version = "1.0", default-features = false, features = ["alloc"] }
```

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

### Unwrap Inner Error

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Method signature and usage example for unwrapping the error, returning a Result.

```rust
pub fn into_inner(self) -> Result<E, Self>
```

```rust
use winnow::error::ErrMode;

let backtrack: ErrMode<i32> = ErrMode::Backtrack(42);
assert_eq!(backtrack.into_inner(), Ok(42));
```

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

### Configure Benchmark Profile

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Optimizes benchmark builds with debug symbols, LTO, and single codegen units.

```toml
[profile.bench]
debug = true
lto = true
codegen-units = 1
```

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

### Configure and use debug feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable parser tracing and debugging output, requiring the std feature.

```toml
debug = ["std", "dep:anstream", "dep:anstyle", "dep:is_terminal_polyfill", "dep:terminal_size"]
```

```rust
use winnow::prelude::*;
use winnow::combinator::trace;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    trace("my_parser", winnow::ascii::alpha1).parse_next(input)
    // Only produces output with debug feature enabled
}
```

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

### take

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Takes a specific number of tokens from the input.

```APIDOC
## take

### Description
Take a specific number of tokens.

### Signature
`pub fn take<I, E>(count: usize) -> impl FnMut(&mut I) -> Result<<I as Stream>::Slice, E>`

### Parameters
- **count** (usize) - Number of tokens to consume

### Return Type
Slice of consumed tokens.
```

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

### Configure simd feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable SIMD optimizations for faster string searching.

```toml
simd = ["dep:memchr"]
```

```toml
[dependencies]
winnow = { version = "1.0", features = ["simd"] }
```

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

### Configure Minimal Parser Dependency

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enables heap allocation and ASCII-based parsing while remaining compatible with no_std environments.

```toml
[dependencies]
winnow = { version = "1.0", default-features = false, features = ["alloc", "parser", "ascii"] }
```

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

### Match any token with any

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Matches any single token from the input stream.

```rust
use winnow::prelude::*;
use winnow::token::any;

fn parser(input: &mut &str) -> winnow::ModalResult<char> {
    any.parse_next(input)
}

assert_eq!(parser.parse_peek("abc"), Ok(("bc", 'a')));
```

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

### Create Needed Instance

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Constructs a Needed instance, where 0 indicates an unknown amount.

```rust
pub fn new(s: usize) -> Self
```

```rust
use winnow::stream::Needed;

let needed = Needed::new(10);
assert_eq!(needed, Needed::Size(std::num::NonZeroUsize::new(10).unwrap()));

let unknown = Needed::new(0);
assert_eq!(unknown, Needed::Unknown);
```

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

### Empty Parser with empty

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Always succeeds without consuming any input.

```rust
use winnow::prelude::*;
use winnow::combinator::empty;

fn parser(input: &mut &str) -> winnow::ModalResult<()> {
    empty.parse_next(input)
}

let mut input = "hello";
assert_eq!(parser(&mut input), Ok(()));
assert_eq!(input, "hello");  // Unchanged
```

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

### Map Inner Error

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Method signature and usage example for applying a transformation function to the inner error value.

```rust
pub fn map<E2, F>(self, f: F) -> ErrMode<E2>
where
    F: FnOnce(E) -> E2
```

```rust
use winnow::error::ErrMode;

let err: ErrMode<u32> = ErrMode::Backtrack(42);
let mapped = err.map(|e| e as i32);
assert!(matches!(mapped, ErrMode::Backtrack(42)));
```

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

### Configure binary feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable parsers for binary formats like integers and bit fields.

```toml
binary = ["parser"]
```

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

### any

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Matches any single token from the input stream.

```APIDOC
## any

### Description
Matches any single token from the input stream.

### Signature
`pub fn any<I, E>(input: &mut I) -> Result<<I as Stream>::Token, E>`

### Return Type
The next token from the stream.

### Example
```rust
use winnow::prelude::*;
use winnow::token::any;

fn parser(input: &mut &str) -> winnow::ModalResult<char> {
    any.parse_next(input)
}

assert_eq!(parser.parse_peek("abc"), Ok(("bc", 'a')));
```
```

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

### Dependency Feature Configurations

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Select appropriate feature flags based on the target environment and performance requirements.

```toml
[dependencies]
winnow = { version = "1.0", features = ["ascii"] }
```

```toml
[dependencies]
winnow = { version = "1.0", features = ["binary"] }
```

```toml
[dependencies]
winnow = { version = "1.0", default-features = false, features = ["parser", "ascii"] }
```

```toml
[dependencies]
winnow = { version = "1.0", features = ["simd"] }
```

```toml
[dependencies]
winnow = { version = "1.0", features = ["debug", "simd"] }
```

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

### Winnow Documentation File Structure

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/MANIFEST.md

The directory layout of the winnow technical reference documentation.

```text
output/
├── README.md                      (432 lines) Main index and overview
├── types.md                       (586 lines) All named types, type aliases, and generics
├── errors.md                      (574 lines) Error types and failure conditions
├── configuration.md               (493 lines) Features, build settings, dependencies
└── api-reference/
    ├── parser.md                  (463 lines) Parser trait and all methods
    ├── stream.md                  (484 lines) Stream trait and input types
    ├── error.md                   (480 lines) Error types and error traits
    ├── combinators.md             (667 lines) All parser combinators
    ├── token.md                   (407 lines) Token-level parsers
    ├── ascii.md                   (453 lines) ASCII character class parsers
    └── binary.md                  (465 lines) Binary format parsers
```

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

### Parse binary data with winnow

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/README.md

Demonstrates parsing a big-endian 32-bit integer from a byte slice.

```rust
use winnow::prelude::*;
use winnow::binary::be_u32;

fn parse_magic(input: &mut &[u8]) -> winnow::ModalResult<u32> {
    be_u32.parse_next(input)
}

let magic_bytes = &[0x12, 0x34, 0x56, 0x78];
assert_eq!(parse_magic.parse_peek(magic_bytes), Ok((&[][..], 0x12345678u32)));
```

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

### Binary Parsing in Complete and Streaming Modes

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Demonstrates parsing a big-endian 32-bit integer using both complete and streaming modes. Streaming mode requires wrapping the input in Partial to handle incomplete data.

```rust
use winnow::prelude::*;
use winnow::{Partial, error::ContextError, error::ErrMode};
use winnow::binary::be_u32;

// Complete mode
let result = be_u32::<_, ContextError>
    .parse_peek(&[0x12, 0x34, 0x56, 0x78][..]);
assert_eq!(result, Ok((&[][..], 0x12345678u32)));

// Streaming mode
let result = be_u32::<_, ErrMode<ContextError>>
    .parse_peek(Partial::new(&[0x12, 0x34][..]));
assert_eq!(result, Err(ErrMode::Incomplete(winnow::stream::Needed::Size(
    std::num::NonZeroUsize::new(2).unwrap()
))));
```

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

### Configure unstable-recover feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable experimental error recovery combinators.

```toml
unstable-recover = ["parser"]
```

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

### Handle Incomplete Parsing

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/errors.md

Demonstrates how a parser returns an Incomplete error when using partial streams.

```rust
use winnow::prelude::*;
use winnow::Partial;
use winnow::error::{ErrMode, ContextError};

let input = Partial::new("");
let result = winnow::ascii::alpha1::<_, ErrMode<ContextError>>
    .parse_next(&mut winnow::stream::Stream::clone(&input));

// Result could be: Err(ErrMode::Incomplete(Needed::Unknown))
```

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

### Configure ascii feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable ASCII-specific parsers and character classes.

```toml
ascii = ["parser"]
```

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

### Define and Use Stateful

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/types.md

Threads global state through a parser.

```rust
pub struct Stateful<S, T>(pub S, pub T);
```

```rust
use winnow::stream::Stateful;

struct ParserState { line: usize };
let state = ParserState { line: 1 };
let input = Stateful(state, "hello");
```

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

### Try alternative parsers with alt

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Uses alt to attempt a sequence of parsers, returning the result of the first successful one. Backtracking occurs on error unless a cut error is encountered.

```rust
use winnow::prelude::*;
use winnow::combinator::alt;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    alt(("hello", "world")).parse_next(input)
}

assert_eq!(parser.parse_peek("hello"), Ok(("", "hello")));
assert_eq!(parser.parse_peek("world"), Ok(("", "world")));
assert!(parser.parse_peek("foo").is_err());
```

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

### from_input Method Signature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Signature for creating an error from the current input position.

```rust
fn from_input(input: &I) -> Self
```

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

### fail

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Always fails.

```APIDOC
## fail

### Description
Always fail (inverse of `empty`).

### Signature
`pub fn fail<I, O, E>(_: &mut I) -> Result<O, E>`
```

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

### Define and Use Partial

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/types.md

Marks an input stream as partial, enabling ErrMode::Incomplete responses.

```rust
pub struct Partial<T>(pub T);
```

```rust
use winnow::prelude::*;
use winnow::Partial;

let input = Partial::new("hello");
// Parser can return Incomplete if more data needed
```

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

### Enable no_std Compatibility

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Configure the crate to operate without the standard library for embedded environments.

```rust
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
```

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

### Match digit tokens using ranges

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Demonstrates using a character range with one_of to match digits.

```rust
use winnow::prelude::*;
use winnow::token::one_of;

fn digit(input: &mut &str) -> winnow::ModalResult<char> {
    one_of('0'..='9').parse_next(input)
}

assert_eq!(digit.parse_peek("5"), Ok(("", '5')));
```

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

### rest

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Returns the remaining input.

```APIDOC
## rest

### Description
Return the remaining input.

### Signature
`pub fn rest<I, E>(input: &mut I) -> Result<<I as Stream>::Slice, E>`

### Return Type
Remaining input slice.
```

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

### or Method Signature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Signature for combining errors from alternative branches.

```rust
fn or(self, other: Self) -> Self
```

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

### Configure parser feature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Enable the base Parser trait and associated combinators.

```toml
parser = []
```

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

### Implement ContextError usage

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/errors.md

Demonstrates using the context method to provide debugging information during parser failure.

```rust
use winnow::prelude::*;
use winnow::error::ContextError;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    winnow::ascii::alpha1
        .context("expected alphabetic characters")
        .parse_next(input)
}
```

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

### is_partial_supported Method

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Checks if partial input is supported at compile-time.

```rust
fn is_partial_supported() -> bool
```

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

### take_until

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Takes tokens until a literal sequence is found.

```APIDOC
## take_until

### Description
Take tokens until a literal sequence is found.

### Signature
`pub fn take_until<I, T, E>(range: impl Into<Range<usize>>, literal: T) -> impl FnMut(&mut I) -> Result<<I as Stream>::Slice, E>`

### Parameters
- **range** (Range) - Min/max count
- **literal** (T) - Sequence to find

### Return Type
Slice until literal found.
```

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

### Handle streaming and complete parsing modes

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/ascii.md

Compares behavior between complete mode and streaming mode using Partial for incomplete input handling.

```rust
use winnow::prelude::*;
use winnow::{Partial, error::ContextError, error::ErrMode};
use winnow::ascii::alpha1;

// Complete mode
let result = alpha1::<_, ContextError>
    .parse_peek("hello123");
assert_eq!(result, Ok(("123", "hello")));

// Streaming/Partial mode
let result = alpha1::<_, ErrMode<ContextError>>
    .parse_peek(Partial::new(""));
assert_eq!(result, Err(ErrMode::Incomplete(winnow::stream::Needed::Unknown)));
```

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

### Set Minimum Supported Rust Version

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Defines the minimum required Rust version for the project.

```toml
rust-version = "1.65.0"
```

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

### by_ref

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Treats &mut Self as a parser to allow reference-based parsing.

```APIDOC
## fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>

### Description
Helps when needing to move a parser when all you have is a &mut Parser. Prevents consuming the parser while allowing it to be used in combinators.

### Return Type
ByRef<'_, Self, I, O, E> - A wrapper allowing reference-based parsing.
```

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

### length_and_then

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Parses N bytes, then applies a secondary parser to those extracted bytes.

```APIDOC
## length_and_then

### Description
Parse N bytes then apply parser to those bytes.

### Parameters
- **length_parser** (Parser) - Required - Parses byte count
- **parser** (Parser) - Required - Applied to the extracted bytes

### Return Type
Result from parser on extracted bytes.
```

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

### bits::take

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Consumes a specific number of bits from the stream.

```APIDOC
## bits::take

### Description
Takes a specific number of bits from the input stream.

### Parameters
- **count** (usize) - Required - Number of bits to consume (0-32).

### Return Type
`u32` containing the bits.
```

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

### Consume tokens with take

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Consumes a fixed number of tokens from the input stream.

```rust
use winnow::prelude::*;
use winnow::token::take;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    take(4usize).parse_next(input)
}

assert_eq!(parser.parse_peek("hello"), Ok(("o", "hell")));
```

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

### with_span(self)

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Returns both the span and the parsed output.

```APIDOC
## with_span(self)

### Description
Return both the span and the parsed output.

### Signature
`fn with_span(self) -> WithSpan<Self, I, O, E>`

### Return Type
`WithSpan<Self, I, O, E>` - Parser returning `(O, Span)`.

### Example
```rust
use winnow::prelude::*;
use winnow::ascii::alpha1;

fn parser(input: &mut &str) -> winnow::ModalResult<(&str, &str)> {
    alpha1.with_span().parse_next(input)
}

let (result, span) = parser.parse_peek("hello").unwrap().1;
assert_eq!(result, "hello");
```
```

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

### Parse basic text with winnow

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/README.md

Uses separated_pair to parse a key-value pair separated by a colon.

```rust
use winnow::prelude::*;
use winnow::ascii::{alpha1, digit1};
use winnow::combinator::separated_pair;

fn identifier(input: &mut &str) -> winnow::ModalResult<(&str, &str)> {
    separated_pair(alpha1, ":", digit1).parse_next(input)
}

fn main() {
    let result = identifier.parse("hello:42");
    assert_eq!(result, Ok(("hello", "42")));
}
```

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

### Configure Text Only Dependency

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Supports text and string parsing with character classes, excluding binary-specific parsers.

```toml
[dependencies]
winnow = { version = "1.0", default-features = false, features = ["ascii"] }
```

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

### Caseless Matching

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/ascii.md

A wrapper for performing case-insensitive string matching.

```APIDOC
## Caseless

### Description
Wrapper for case-insensitive string matching.

### Signature
`pub struct Caseless<T>(pub T);`

### Constructor
`pub fn new(value: T) -> Self`
```

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

### Set Rust Edition

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Specifies the Rust edition for the project.

```toml
edition = "2021"
```

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

### Configure default feature flags

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Defines the default set of features enabled for the winnow crate in Cargo.toml.

```toml
default = ["std", "ascii", "binary"]
```

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

### repeat

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Applies a parser between m and n times, returning the results in a Vec.

```APIDOC
## repeat

### Description
Apply parser between m and n times, returning results in a Vec.

### Signature
`pub fn repeat<I, O, E, F>(range: impl Into<std::ops::Range<usize>>, parser: F) -> Repeat<F>`

### Parameters
- **range** (Range<usize>) - Range of repetitions (e.g., 1..=3, 0.., 3)
- **parser** (Parser) - Parser to repeat

### Return Type
`Repeat<F>` - Parser collecting results in Vec.
```

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

### Define StrContext and StrContextValue

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Defines context types and expected values for string parsing errors.

```rust
pub enum StrContext {
    Label(&'static str),
    Expected(StrContextValue),
}
```

```rust
pub enum StrContextValue {
    Description(&'static str),
    Char(char),
    Tag(&'static str),
}
```

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

### take_while

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Takes tokens while a predicate matches.

```APIDOC
## take_while

### Description
Take tokens while predicate matches.

### Signature
`pub fn take_while<I, C, E>(range: impl Into<Range<usize>>, tokens: C) -> impl FnMut(&mut I) -> Result<<I as Stream>::Slice, E>`

### Parameters
- **range** (Range) - Min/max count (e.g., 0.., 1..=3)
- **tokens** (C) - Token set to match

### Return Type
Slice of matching tokens.
```

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

### not

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Succeeds only if the embedded parser returns Backtrack or Incomplete.

```APIDOC
## not

### Description
Parse succeeds only if the embedded parser returns `Backtrack` or `Incomplete`.

### Signature
`pub fn not<I, O, E, F>(mut parser: F) -> impl FnMut(&mut I) -> Result<(), E>`

### Parameters
- **parser** (Parser) - The parser to negate (must fail).
```

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

### offset_for

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Find the offset of the next matching token.

```APIDOC
## fn offset_for<P>(&self, predicate: P) -> Option<usize>

### Description
Find the offset of the next matching token.

### Parameters
- **predicate** (P) - Required - Function returning true for matching tokens

### Return Type
Option<usize> - Offset of first matching token or None.
```

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

### Configure Binary Only Dependency

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/configuration.md

Optimized for binary format parsing without ASCII character classes.

```toml
[dependencies]
winnow = { version = "1.0", default-features = false, features = ["binary"] }
```

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

### none_of

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Matches any token except those provided in the set.

```APIDOC
## none_of

### Description
Matches anything except the provided tokens.

### Signature
`pub fn none_of<I, C, E>(tokens: C) -> impl FnMut(&mut I) -> Result<<I as Stream>::Token, E>`

### Parameters
- **tokens** (C) - Set of tokens to exclude

### Return Type
Token not in the provided set.

### Example
```rust
use winnow::prelude::*;
use winnow::token::none_of;

fn parser(input: &mut &str) -> winnow::ModalResult<char> {
    none_of("xyz").parse_next(input)
}

assert_eq!(parser.parse_peek("abc"), Ok(("bc", 'a')));
assert!(parser.parse_peek("xyz").is_err());
```
```

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

### checkpoint

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Save the current parse location.

```APIDOC
## fn checkpoint(&self) -> Self::Checkpoint

### Description
Save the current parse location.

### Return Type
Self::Checkpoint - A checkpoint to restore later.
```

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

### Select parser based on output with dispatch

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Uses dispatch to match on the output of a parser to determine which subsequent parser to execute.

```rust
use winnow::prelude::*;
use winnow::combinator::dispatch;
use winnow::token::one_of;

fn parser(input: &mut &str) -> winnow::ModalResult<u32> {
    dispatch(one_of("+-"), |sign| {
        move |input: &mut &str| {
            let num = winnow::ascii::dec_uint.parse_next(input)?;
            match sign {
                '+' => Ok(num),
                '-' => Ok(num as u32),
                _ => unreachable!(),
            }
        }
    }).parse_next(input)
}
```

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

### incomplete Method Signature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Signature for marking an error as needing more data.

```rust
fn incomplete(input: &I, needed: Needed) -> Self
```

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

### Implement EmptyError usage

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/errors.md

Demonstrates using EmptyError to ignore error details.

```rust
use winnow::prelude::*;
use winnow::error::EmptyError;

let result = winnow::ascii::alpha1::<_, EmptyError>
    .parse_next(&mut "hello");
```

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

### Define Caseless matching structure

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/ascii.md

Shows the struct definition and constructor for the Caseless wrapper.

```rust
pub struct Caseless<T>(pub T);

impl<T> Caseless<T> {
    pub fn new(value: T) -> Self
}
```

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

### separated

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Applies a parser and a separator between m and n times.

```APIDOC
## separated

### Description
Apply parser and separator between m and n times.

### Signature
`pub fn separated<I, O, E, F, G>(range: impl Into<std::ops::Range<usize>>, mut parser: F, mut sep: G) -> impl FnMut(&mut I) -> Result<Vec<O>, E>`

### Parameters
- **range** (Range<usize>) - Repetition range
- **parser** (Parser) - Parser to repeat
- **sep** (Parser) - Separator parser

### Return Type
Result containing Vec of parsed items.
```

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

### Handle streaming or partial input

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/README.md

Uses Partial to handle incomplete data streams during parsing.

```rust
use winnow::prelude::*;
use winnow::Partial;
use winnow::error::{ErrMode, ContextError};

let input = Partial::new("hello");
let result = winnow::ascii::alpha1::<_, ErrMode<ContextError>>
    .parse_next(&mut winnow::stream::Stream::clone(&input));
assert!(result.is_ok());
```

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

### Use AsChar trait methods with take_while

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/ascii.md

Demonstrates using AsChar trait methods like is_alpha as predicates within a take_while parser.

```rust
use winnow::prelude::*;
use winnow::stream::AsChar;
use winnow::token::take_while;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    take_while(0.., |c: char| c.is_alpha()).parse_next(input)
}

assert_eq!(parser.parse_peek("abc123"), Ok(("123", "abc")));
```

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

### length_take

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/binary.md

Takes N bytes from the input, where N is determined by a provided length parser.

```APIDOC
## length_take

### Description
Take N bytes where N is parsed by the first parser.

### Parameters
- **length_parser** (Parser) - Required - Parses the length value

### Return Type
Slice of N bytes.
```

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

### complete_err(self)

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Converts Incomplete to Backtrack error.

```APIDOC
## complete_err(self)

### Description
Convert `Incomplete` to `Backtrack` error. When a parser returns `ErrMode::Incomplete`, this converts it to `ErrMode::Backtrack` to disable backtracking prevention.

### Signature
`fn complete_err(self) -> CompleteErr<Self, I, O, E>`

### Return Type
`CompleteErr<Self, I, O, E>` - Parser treating incomplete as backtrack.

### Example
```rust
use winnow::prelude::*;
use winnow::Partial;

fn parser(input: &mut winnow::Partial<&str>) -> winnow::ModalResult<&str> {
    winnow::ascii::alpha1.complete_err().parse_next(input)
}
```
```

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

### take_till

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/token.md

Takes tokens until a predicate matches.

```APIDOC
## take_till

### Description
Take tokens until predicate matches.

### Signature
`pub fn take_till<I, C, E>(range: impl Into<Range<usize>>, tokens: C) -> impl FnMut(&mut I) -> Result<<I as Stream>::Slice, E>`

### Parameters
- **range** (Range) - Min/max count
- **tokens** (C) - Token set to stop at

### Return Type
Slice until stopping token.
```

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

### alt

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

The alt combinator attempts a list of parsers in sequence and returns the result of the first successful one. It supports backtracking on error and handles cut errors by returning immediately.

```APIDOC
## alt

### Description
Try a list of parsers and return the result of the first successful one.

### Signature
`pub fn alt<I, O, E, F>(mut parsers: F) -> Alt<F>`

### Parameters
- **parsers** (F) - Required - Tuple or array of parsers to try in sequence

### Return Type
`Alt<F>` - Parser combining alternatives.

### Example
```rust
use winnow::prelude::*;
use winnow::combinator::alt;

fn parser(input: &mut &str) -> winnow::ModalResult<&str> {
    alt(("hello", "world")).parse_next(input)
}

assert_eq!(parser.parse_peek("hello"), Ok(("", "hello")));
assert_eq!(parser.parse_peek("world"), Ok(("", "world")));
assert!(parser.parse_peek("foo").is_err());
```
```

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

### Deprecation Documentation Template

Source: https://github.com/winnow-rs/winnow/blob/main/DESIGN.md

Use this template in docstrings when deprecating an API to provide clear migration paths and issue tracking.

```rust
/// Deprecated in [Issue #XXX](https://github.com/winnow-rs/winnow/issues/XXX), replaced with [intra-doc-link]`
#[doc(alias = "OLD_NAME")]
#[deprecated(since = "X.Y.Z", note = "replaced with `ITEM` in Issue #XXX")]`
```

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

### ByRef Parser Wrapper

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/types.md

Allows &mut Parser to be used where Parser is needed.

```rust
pub struct ByRef<'a, P, I, O, E> {
    // Reference-based parser wrapper
}
```

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

### Produce a constant value with value

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/parser.md

Returns a specified value instead of the actual parsed output.

```rust
use winnow::prelude::*;
use winnow::ascii::alpha1;

fn parser(input: &mut &str) -> winnow::ModalResult<i32> {
    alpha1.value(1234).parse_next(input)
}

assert_eq!(parser.parse_peek("abcd"), Ok(("", 1234)));
```

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

### Repeat and Fold Input

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/README.md

Repeats a parser and folds the results into an accumulator.

```rust
use winnow::prelude::*;
use winnow::combinator::repeat;

fn sum(input: &mut &str) -> winnow::ModalResult<u32> {
    repeat(1.., winnow::ascii::dec_uint)
        .fold(|| 0, |acc, val| acc + val)
        .parse_next(input)
}
```

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

### peek

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Parses without consuming input.

```APIDOC
## peek

### Description
Parse without consuming input. The input remains unchanged regardless of the parser result.

### Signature
`pub fn peek<I, O, E, F>(mut parser: F) -> impl FnMut(&mut I) -> Result<O, E>`

### Parameters
- **parser** (Parser) - The parser to apply without consuming.
```

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

### Repeat with separator

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Applies a parser and a separator between m and n times.

```rust
use winnow::prelude::*;
use winnow::combinator::separated;

fn parser(input: &mut &str) -> winnow::ModalResult<Vec<&str>> {
    separated(1..=3, "ab", ",").parse_next(input)
}

assert_eq!(parser.parse_peek("ab,ab,ab."), Ok((".", vec!["ab", "ab", "ab"])));
```

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

### Define StrContext

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/types.md

Provides context information specifically for string or ASCII-based parsing errors.

```rust
pub enum StrContext {
    Label(&'static str),
    Expected(StrContextValue),
}
```

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

### Use FromExternalError with try_map

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Demonstrates converting an external error within a parser using try_map.

```rust
use winnow::prelude::*;
use winnow::error::{FromExternalError, ContextError};

let parser = winnow::ascii::dec_uint::<_, ContextError>
    .try_map(|n: u32| {
        if n > 100 {
            Err("value too large")
        } else {
            Ok(n)
        }
    });
```

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

### append Method Signature

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/error.md

Signature for merging errors and accumulating context.

```rust
fn append(self, input: &I, token_start: &I::Checkpoint) -> Self
```

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

### opt

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Makes a parser optional, returning Option<O>.

```APIDOC
## opt

### Description
Make a parser optional, returning `Option<O>`. If the parser fails, it returns `None` instead of an error.

### Signature
`pub fn opt<I, O, E, F>(mut parser: F) -> impl FnMut(&mut I) -> Result<Option<O>, E>`

### Parameters
- **parser** (Parser) - The parser to make optional.
```

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

### Optional Parsing with opt

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Makes a parser optional, returning Some(output) on success or None on backtrack.

```rust
use winnow::prelude::*;
use winnow::combinator::opt;

fn parser(input: &mut &str) -> winnow::ModalResult<Option<&str>> {
    opt("hello").parse_next(input)
}

assert_eq!(parser.parse_peek("hello"), Ok(("", Some("hello"))));
assert_eq!(parser.parse_peek("world"), Ok(("world", None)));
```

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

### repeat_till

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/combinators.md

Applies the first parser until the second parser succeeds.

```APIDOC
## repeat_till

### Description
Apply first parser until second parser succeeds.

### Signature
`pub fn repeat_till<I, O, O2, E, F, G>(mut parser: F, mut till: G) -> impl FnMut(&mut I) -> Result<(Vec<O>, O2), E>`

### Parameters
- **parser** (Parser) - Parser to repeat
- **till** (Parser) - Terminator parser

### Return Type
Result containing (Vec of results, terminator output).
```

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

### finish

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Advance to the end of the stream.

```APIDOC
## fn finish(&mut self) -> Self::Slice

### Description
Advance to the end of the stream.

### Return Type
Self::Slice - Remaining input (rest of stream).
```

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

### space0 / space1

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/ascii.md

Recognize zero or more (space0) or one or more (space1) ASCII spaces and tabs.

```APIDOC
## space0 / space1

### Description
Recognize zero or more (space0) or one or more (space1) ASCII spaces and tabs.

### Signature
```rust
pub fn space0<Input, Error>(input: &mut Input) -> Result<<Input as Stream>::Slice, Error>
pub fn space1<Input, Error>(input: &mut Input) -> Result<<Input as Stream>::Slice, Error>
```
```

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

### Checkpoint and reset stream

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/api-reference/stream.md

Use checkpoint to save the current state and reset to revert the stream to that saved position.

```rust
use winnow::stream::Stream;

let mut input = "hello";
let checkpoint = input.checkpoint();
input.next_token();
input.reset(&checkpoint);
assert_eq!(input.peek_token(), Some('h'));
```

```rust
use winnow::stream::Stream;

let mut input = "hello";
let checkpoint = input.checkpoint();
input.next_token();
input.reset(&checkpoint);
// input is back to "hello"
```

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

### Add custom error context

Source: https://github.com/winnow-rs/winnow/blob/main/_autodocs/README.md

Attaches descriptive context to a parser to improve error reporting.

```rust
use winnow::prelude::*;
use winnow::ascii::alpha1;

fn name(input: &mut &str) -> winnow::ModalResult<&str> {
    alpha1.context("person name").parse_next(input)
}

// On error, context is accumulated and reported
```
Tokens:
Raw