Trait Parser Copy item path

// Matches a number with underscores that is surrounded by apostrophes.
let quoted_numeric = any::<&str, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_digit(10))
    .separated_by(just("_").repeated().at_most(1))
    .to_slice()
    .padded_by(just("'"));
assert_eq!(quoted_numeric.parse("'1_23'").into_result(), Ok("1_23"));

// Matches even numbers, then ignoring the rest of the input when an odd number is reached.
let even_matcher = any::<&[u32], extra::Err<Simple<u32>>>()
    .filter(|c: &u32| c % 2 == 0)
    .repeated()
    .to_slice()
    .lazy();
assert_eq!(even_matcher.parse(&[2, 4, 8, 5, 6]).unwrap(), &[2, 4, 8]);

let lowercase = any::<_, extra::Err<Simple<char>>>()
    .filter(char::is_ascii_lowercase)
    .repeated()
    .at_least(1)
    .collect::<String>();

assert_eq!(lowercase.parse("hello").into_result(), Ok("hello".to_string()));
assert!(lowercase.parse("Hello").has_errors());

#[derive(Debug, PartialEq)]
enum Token { Word(String), Num(u64) }

let word = any::<_, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_alphabetic())
    .repeated().at_least(1)
    .collect::<String>()
    .map(Token::Word);

let num = any::<_, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_ascii_digit())
    .repeated().at_least(1)
    .collect::<String>()
    .map(|s| Token::Num(s.parse().unwrap()));

let token = word.or(num);

assert_eq!(token.parse("test").into_result(), Ok(Token::Word("test".to_string())));
assert_eq!(token.parse("42").into_result(), Ok(Token::Num(42)));

// It's common for AST nodes to use a wrapper type that allows attaching span information to them
#[derive(Debug, PartialEq)]
pub struct Spanned<T>(T, SimpleSpan<usize>);

let ident = text::ascii::ident::<_, extra::Err<Simple<char>>>()
    .map_with(|ident, e| Spanned(ident, e.span())) // Equivalent to `.map_with_span(|ident, span| Spanned(ident, span))`
    .padded();

assert_eq!(ident.parse("hello").into_result(), Ok(Spanned("hello", (0..5).into())));
assert_eq!(ident.parse("       hello   ").into_result(), Ok(Spanned("hello", (7..12).into())));

use std::ops::Range;
use lasso::{Rodeo, Spur};

// It's common for AST nodes to use interned versions of identifiers
// Keys are generally smaller, faster to compare, and can be `Copy`
#[derive(Copy, Clone)]
pub struct Ident(Spur);

let ident = text::ascii::ident::<_, extra::Full<Simple<char>, extra::SimpleState<Rodeo>, ()>>()
    .map_with(|ident, e| Ident(e.state().get_or_intern(ident)))
    .padded()
    .repeated()
    .at_least(1)
    .collect::<Vec<_>>();

// Test out parser

let mut interner = extra::SimpleState(Rodeo::new());

match ident.parse_with_state("hello", &mut interner).into_result() {
    Ok(idents) => {
        assert_eq!(interner.resolve(&idents[0].0), "hello");
    }
    Err(e) => panic!("Parsing Failed: {:?}", e),
}

match ident.parse_with_state("hello hello", &mut interner).into_result() {
    Ok(idents) => {
        assert_eq!(idents[0].0, idents[1].0);
    }
    Err(e) => panic!("Parsing Failed: {:?}", e),
}

fn palindrome_parser<'src>() -> impl Parser<'src, &'src str, String> {
    recursive(|chain| {
        choice((
            just(String::new())
                .configure(|cfg, ctx: &String| cfg.seq(ctx.clone()))
                .then_ignore(end()),
            any()
                .map_with(|x, e| format!("{x}{}", e.ctx()))
                .ignore_with_ctx(chain),
        ))
    })
    .with_ctx(String::new())
}

assert_eq!(palindrome_parser().parse("abccba").into_result().as_deref(), Ok("cba"));
assert_eq!(palindrome_parser().parse("hello  olleh").into_result().as_deref(), Ok(" olleh"));
assert!(palindrome_parser().parse("abccb").into_result().is_err());

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Value {
      One(u8),
     Two(u8, u8),
     Three(u8, u8, u8),
}

fn parser<'src>() -> impl Parser<'src, &'src [u8], Vec<Value>> {
    choice((
        just(1).ignore_then(any()).map(Value::One),
        just(2)
            .ignore_then(group((any(), any())))
            .map_group(Value::Two),
        just(3)
            .ignore_then(group((any(), any(), any())))
            .map_group(Value::Three),
    ))
    .repeated()
    .collect()
}

let bytes = &[3, 1, 2, 3, 1, 127, 2, 21, 69];
assert_eq!(
    parser().parse(bytes).into_result(),
    Ok(vec![
        Value::Three(1, 2, 3),
        Value::One(127),
        Value::Two(21, 69)
    ])
);

// It's common for AST nodes to use a wrapper type that allows attaching span information to them
#[derive(Debug, PartialEq)]
pub enum Expr<'src> {
    Int(&'src str, SimpleSpan),
    // The span is that of the operator, '+'
    Add(Box<Expr<'src>>, SimpleSpan, Box<Expr<'src>>),
}

let int = text::int::<_, extra::Err<Simple<char>>>(10)
    .to_slice()
    .map_with(|int, e| Expr::Int(int, e.span()))
    .padded();

let add_op = just('+').to_span().padded();
let sum = int.foldl(
    add_op.then(int).repeated(),
    |a, (op_span, b)| Expr::Add(Box::new(a), op_span, Box::new(b)),
);

assert_eq!(sum.parse("42 + 7 + 13").into_result(), Ok(Expr::Add(
    Box::new(Expr::Add(
        Box::new(Expr::Int("42", (0..2).into())),
        (3..4).into(),
        Box::new(Expr::Int("7", (5..6).into())),
    )),
    (7..8).into(),
    Box::new(Expr::Int("13", (9..11).into())),
)));

let int = text::int::<_, extra::Err<Simple<char>>>(10)
    .from_str::<u8>()
    .unwrapped();

let sum = int
    .clone()
    .try_foldl(just('+').ignore_then(int).repeated(), |a, b, e| a.checked_add(b).ok_or(Simple::new(None, e.span())));

assert_eq!(sum.parse("1+12+3+9").into_result(), Ok(25));
assert_eq!(sum.parse("6").into_result(), Ok(6));
assert!(sum.parse("255+1").has_errors()); // due to u8 overflow

let byte = text::int::<_, extra::Err<Rich<char>>>(10)
    .try_map(|s: &str, span| s
        .parse::<u8>()
        .map_err(|e| Rich::custom(span, e)));

assert!(byte.parse("255").has_output());
assert!(byte.parse("256").has_errors()); // Out of range

// A parser that parses any number of whitespace characters without allocating
let whitespace = any::<_, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_whitespace())
    .ignored()
    .repeated()
    .collect::<Vec<_>>();

assert_eq!(whitespace.parse("    ").into_result(), Ok(vec![(); 4]));
assert!(whitespace.parse("  hello").has_errors());

#[derive(Clone, Debug, PartialEq)]
enum Op { Add, Sub, Mul, Div }

let op = just::<_, _, extra::Err<Simple<char>>>('+').to(Op::Add)
    .or(just('-').to(Op::Sub))
    .or(just('*').to(Op::Mul))
    .or(just('/').to(Op::Div));

assert_eq!(op.parse("+").into_result(), Ok(Op::Add));
assert_eq!(op.parse("/").into_result(), Ok(Op::Div));

let word = any::<_, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_alphabetic())
    .repeated()
    .at_least(1)
    .collect::<String>();
let two_words = word.then_ignore(just(' ')).then(word);

assert_eq!(two_words.parse("dog cat").into_result(), Ok(("dog".to_string(), "cat".to_string())));
assert!(two_words.parse("hedgehog").has_errors());

let zeroes = any::<_, extra::Err<Simple<char>>>().filter(|c: &char| *c == '0').ignored().repeated().collect::<Vec<_>>();
let digits = any().filter(|c: &char| c.is_ascii_digit())
    .repeated()
    .collect::<String>();
let integer = zeroes
    .ignore_then(digits)
    .from_str()
    .unwrapped();

assert_eq!(integer.parse("00064").into_result(), Ok(64));
assert_eq!(integer.parse("32").into_result(), Ok(32));

let word = any::<_, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_alphabetic())
    .repeated()
    .at_least(1)
    .collect::<String>();

let punctuated = word
    .then_ignore(just('!').or(just('?')).or_not());

let sentence = punctuated
    .padded() // Allow for whitespace gaps
    .repeated()
    .collect::<Vec<_>>();

assert_eq!(
    sentence.parse("hello! how are you?").into_result(),
    Ok(vec![
        "hello".to_string(),
        "how".to_string(),
        "are".to_string(),
        "you".to_string(),
    ]),
);

#[derive(Debug, Clone, PartialEq)]
enum Token<'src> {
    Struct,
    Ident(&'src str),
    Item(&'src str),
    Group(Vec<Token<'src>>),
}

let group = select_ref! { Token::Group(g) => g.as_slice() };

let ident = select_ref! { Token::Ident(i) => *i };

let items = select_ref! { Token::Item(i) => *i }
    .repeated()
    .collect::<Vec<_>>()
    .nested_in(group);

let struc = just::<_, _, extra::Err<Simple<_>>>(&Token::Struct)
    .ignore_then(ident)
    .then(items);

let tl = struc
    .repeated()
    .collect::<Vec<_>>();

let tokens = [
    Token::Struct,
    Token::Ident("foo"),
    Token::Group(vec![
        Token::Item("a"),
        Token::Item("b"),
    ]),
];

assert_eq!(tl.parse(&tokens).into_result(), Ok(vec![("foo", vec!["a", "b"])]));

let successor = just(b'\0').configure(|cfg, ctx: &u8| cfg.seq(*ctx + 1));

// A parser that parses a single letter and then its successor
let successive_letters = one_of::<_, _, extra::Err<Simple<u8>>>(b'a'..=b'z')
    .ignore_with_ctx(successor);

assert_eq!(successive_letters.parse(b"ab").into_result(), Ok(b'b')); // 'b' follows 'a'
assert!(successive_letters.parse(b"ac").has_errors()); // 'c' does not follow 'a'

let generic = just(b'0').configure(|cfg, ctx: &u8| cfg.seq(*ctx));

let parse_a = just::<_, _, extra::Default>(b'b').ignore_then(generic.with_ctx(b'a'));
let parse_b = just::<_, _, extra::Default>(b'a').ignore_then(generic.with_ctx(b'b'));

assert_eq!(parse_a.parse(b"ba" as &[_]).into_result(), Ok::<_, Vec<EmptyErr>>(b'a'));
assert!(parse_a.parse(b"bb").has_errors());
assert_eq!(parse_b.parse(b"ab" as &[_]).into_result(), Ok(b'b'));
assert!(parse_b.parse(b"aa").has_errors());

let escape = just("\\n").to('\n');

// C-style string literal
let string = none_of::<_, _, extra::Err<Simple<char>>>('"')
    .and_is(escape.not())
    .or(escape)
    .repeated()
    .collect::<String>()
    .padded_by(just('"'));

assert_eq!(
    string.parse("\"wxyz\"").into_result().as_deref(),
    Ok("wxyz"),
);
assert_eq!(
    string.parse("\"a\nb\"").into_result().as_deref(),
    Ok("a\nb"),
);

// A LISP-style S-expression
#[derive(Debug, PartialEq)]
enum SExpr {
    Ident(String),
    Num(u64),
    List(Vec<SExpr>),
}

let ident = any::<_, extra::Err<Simple<char>>>().filter(|c: &char| c.is_alphabetic())
    .repeated()
    .at_least(1)
    .collect::<String>();

let num = text::int(10)
    .from_str()
    .unwrapped();

let s_expr = recursive(|s_expr| s_expr
    .padded()
    .repeated()
    .collect::<Vec<_>>()
    .map(SExpr::List)
    .delimited_by(just('('), just(')'))
    .or(ident.map(SExpr::Ident))
    .or(num.map(SExpr::Num)));

// A valid input
assert_eq!(
    s_expr.parse("(add (mul 42 3) 15)").into_result(),
    Ok(SExpr::List(vec![
        SExpr::Ident("add".to_string()),
        SExpr::List(vec![
            SExpr::Ident("mul".to_string()),
            SExpr::Num(42),
            SExpr::Num(3),
        ]),
        SExpr::Num(15),
    ])),
);

let ident = text::ascii::ident::<_, extra::Err<Simple<char>>>()
    .padded_by(just('!'));

assert_eq!(ident.parse("!hello!").into_result(), Ok("hello"));
assert!(ident.parse("hello!").has_errors());
assert!(ident.parse("!hello").has_errors());
assert!(ident.parse("hello").has_errors());

let op = just::<_, _, extra::Err<Simple<char>>>('+')
    .or(just('-'))
    .or(just('*'))
    .or(just('/'));

assert_eq!(op.parse("+").into_result(), Ok('+'));
assert_eq!(op.parse("/").into_result(), Ok('/'));
assert!(op.parse("!").has_errors());

let word = any::<_, extra::Err<Simple<char>>>().filter(|c: &char| c.is_alphabetic())
    .repeated()
    .at_least(1)
    .collect::<String>();

let word_or_question = word
    .then(just('?').or_not());

assert_eq!(word_or_question.parse("hello?").into_result(), Ok(("hello".to_string(), Some('?'))));
assert_eq!(word_or_question.parse("wednesday").into_result(), Ok(("wednesday".to_string(), None)));

#[derive(Debug, PartialEq)]
enum Tree<'src> {
    Text(&'src str),
    Group(Vec<Self>),
}

// Arbitrary text, nested in a tree with { ... } delimiters
let tree = recursive::<_, _, extra::Err<Simple<char>>, _, _>(|tree| {
    let text = any()
        .and_is(one_of("{}").not())
        .repeated()
        .at_least(1)
        .to_slice()
        .map(Tree::Text);

    let group = tree
        .repeated()
        .collect()
        .delimited_by(just('{'), just('}'))
        .map(Tree::Group);

    text.or(group)
});

assert_eq!(
    tree.parse("{abcd{efg{hijk}lmn{opq}rs}tuvwxyz}").into_result(),
    Ok(Tree::Group(vec![
        Tree::Text("abcd"),
        Tree::Group(vec![
            Tree::Text("efg"),
            Tree::Group(vec![
                Tree::Text("hijk"),
            ]),
            Tree::Text("lmn"),
            Tree::Group(vec![
                Tree::Text("opq"),
            ]),
            Tree::Text("rs"),
        ]),
        Tree::Text("tuvwxyz"),
    ])),
);

let num = any::<_, extra::Err<Simple<char>>>()
    .filter(|c: &char| c.is_ascii_digit())
    .repeated()
    .at_least(1)
    .collect::<String>()
    .from_str()
    .unwrapped();

let sum = num.clone()
    .foldl(just('+').ignore_then(num).repeated(), |a, b| a + b);

assert_eq!(sum.parse("2+13+4+0+5").into_result(), Ok(24));

let shopping = text::ascii::ident::<_, extra::Err<Simple<char>>>()
    .padded()
    .separated_by(just(','))
    .collect::<Vec<_>>();

assert_eq!(shopping.parse("eggs").into_result(), Ok(vec!["eggs"]));
assert_eq!(shopping.parse("eggs, flour, milk").into_result(), Ok(vec!["eggs", "flour", "milk"]));

let int = text::int::<_, extra::Err<Simple<char>>>(10)
    .from_str()
    .unwrapped();

let sum = int
    .clone()
    .foldl(just('+').ignore_then(int).repeated(), |a, b| a + b);

assert_eq!(sum.parse("1+12+3+9").into_result(), Ok(25));
assert_eq!(sum.parse("6").into_result(), Ok(6));

let int = text::int::<_, extra::Full<Simple<char>, SimpleState<i32>, ()>>(10)
    .from_str()
    .unwrapped();

let sum = int
    .clone()
    .foldl_with(just('+').ignore_then(int).repeated(), |a, b, e| (a + b) * **e.state());

let mut multiplier = SimpleState(2i32);
assert_eq!(sum.parse_with_state("1+12+3+9", &mut multiplier).into_result(), Ok(134));
assert_eq!(sum.parse_with_state("6", &mut multiplier).into_result(), Ok(6));

use slotmap::{new_key_type, SlotMap};

// Metadata type for node Ids for extra type safety
new_key_type! {
   pub struct NodeId;
}

// AST nodes reference other nodes with `NodeId`s instead of containing boxed/owned values
#[derive(Copy, Clone, Debug, PartialEq)]
enum Expr {
    Int(i32),
    Add(NodeId, NodeId),
}

type NodeArena = SlotMap<NodeId, Expr>;

// Now, define our parser
let int = text::int::<&str, extra::Full<Simple<char>, extra::SimpleState<NodeArena>, ()>>(10)
    .padded()
    .map_with(|s, e|
        // Return the ID of the new integer node
        e.state().insert(Expr::Int(s.parse().unwrap()))
    );

let sum = int.foldl_with(
    just('+').padded().ignore_then(int).repeated(),
    |a: NodeId, b: NodeId, e| {
        // Inserting an item into the arena returns its ID
        e.state().insert(Expr::Add(a, b))
    }
);

// Test our parser
let mut arena = extra::SimpleState(NodeArena::default());
let four_plus_eight = sum.parse_with_state("4 + 8", &mut arena).unwrap();
if let Expr::Add(a, b) = arena[four_plus_eight] {
    assert_eq!(arena[a], Expr::Int(4));
    assert_eq!(arena[b], Expr::Int(8));
} else {
    panic!("Not an Expr::Add");
}

let just_numbers = text::digits::<_, extra::Err<Simple<char>>>(10)
    .to_slice()
    .padded()
    .then_ignore(none_of("+-*/").rewind())
    .separated_by(just(','))
    .collect::<Vec<_>>();
// 3 is not parsed because it's followed by '+'.
assert_eq!(just_numbers.lazy().parse("1, 2, 3 + 4").into_result(), Ok(vec!["1", "2"]));

let digits = one_of::<_, _, extra::Err<Simple<char>>>('0'..='9')
    .repeated()
    .collect::<String>()
    .lazy();

assert_eq!(digits.parse("12345abcde").into_result().as_deref(), Ok("12345"));

let ident = text::ascii::ident::<_, extra::Err<Simple<char>>>().padded();

// A pattern with no whitespace surrounding it is accepted
assert_eq!(ident.parse("hello").into_result(), Ok("hello"));
// A pattern with arbitrary whitespace surrounding it is also accepted
assert_eq!(ident.parse(" \t \n  \t   world  \t  ").into_result(), Ok("world"));

#[derive(Debug, PartialEq)]
enum Expr<'src> {
    Error,
    Int(&'src str),
    List(Vec<Expr<'src>>),
}

let recovery = just::<_, _, extra::Err<Simple<char>>>('[')
        .then(none_of(']').repeated().then(just(']')));

let expr = recursive::<_, _, extra::Err<Simple<char>>, _, _>(|expr| expr
    .separated_by(just(','))
    .collect::<Vec<_>>()
    .delimited_by(just('['), just(']'))
    .map(Expr::List)
    // If parsing a list expression fails, recover at the next delimiter, generating an error AST node
    .recover_with(via_parser(recovery.map(|_| Expr::Error)))
    .or(text::int(10).map(Expr::Int))
    .padded());

assert!(expr.parse("five").has_errors()); // Text is not a valid expression in this language...
assert_eq!(
    expr.parse("[1, 2, 3]").into_result(),
    Ok(Expr::List(vec![Expr::Int("1"), Expr::Int("2"), Expr::Int("3")])),
); // ...but lists and numbers are!

// This input has two syntax errors...
let res = expr.parse("[[1, two], [3, four]]");
// ...and error recovery allows us to catch both of them!
assert_eq!(res.errors().len(), 2);
// Additionally, the AST we get back still has useful information.
assert_eq!(res.output(), Some(&Expr::List(vec![Expr::Error, Expr::Error])));

let large_int = text::int::<_, extra::Err<Rich<char>>>(10)
    .from_str()
    .unwrapped()
    .validate(|x: u32, e, emitter| {
        if x < 256 { emitter.emit(Rich::custom(e.span(), format!("{} must be 256 or higher.", x))) }
        x
    });

assert_eq!(large_int.parse("537").into_result(), Ok(537));
assert!(large_int.parse("243").into_result().is_err());

// Start with the same large_int validator
let large_int_val = text::int::<_, extra::Err<Rich<char>>>(10)
        .from_str()
        .unwrapped()
        .validate(|x: u32, e, emitter| {
            if x < 256 { emitter.emit(Rich::custom(e.span(), format!("{} must be 256 or higher", x))) }
            x
        });

// A try_map version of the same parser
let large_int_tm = text::int::<_, extra::Err<Rich<char>>>(10)
        .from_str()
        .unwrapped()
        .try_map(|x: u32, span| {
            if x < 256 {
                Err(Rich::custom(span, format!("{} must be 256 or higher", x)))
            } else {
                Ok(x)
            }
        });

// Parser that uses the validation version
let multi_step_val = large_int_val.then(text::ascii::ident().padded());
// Parser that uses the try_map version
let multi_step_tm = large_int_tm.then(text::ascii::ident().padded());

// On success, both parsers are equivalent
assert_eq!(
    multi_step_val.parse("512 foo").into_result(),
    Ok((512, "foo"))
);

assert_eq!(
    multi_step_tm.parse("512 foo").into_result(),
    Ok((512, "foo"))
);

// However, on failure, they may produce different errors:
assert_eq!(
    multi_step_val.parse("100 2").into_result(),
    Err(vec![
        Rich::<char>::custom((0..3).into(), "100 must be 256 or higher"),
        <Rich<char> as LabelError<&str, _>>::expected_found([TextExpected::<&str>::IdentifierPart], Some(MaybeRef::Val('2')), (4..5).into()),
    ])
);

assert_eq!(
    multi_step_tm.parse("100 2").into_result(),
    Err(vec![Rich::<char>::custom((0..3).into(), "100 must be 256 or higher")])
);

let uint64 = text::int::<_, extra::Err<Simple<char>>>(10)
    .from_str::<u64>()
    .unwrapped();

assert_eq!(uint64.parse("7").into_result(), Ok(7));
assert_eq!(uint64.parse("42").into_result(), Ok(42));

let boolean = just::<_, _, extra::Err<Simple<char>>>("true")
    .or(just("false"))
    .from_str::<bool>()
    .unwrapped(); // Cannot panic: the only possible outputs generated by the parser are "true" or "false"

assert_eq!(boolean.parse("true").into_result(), Ok(true));
assert_eq!(boolean.parse("false").into_result(), Ok(false));
// Does not panic, because the original parser only accepts "true" or "false"
assert!(boolean.parse("42").has_errors());

// Parses whole integers
let num = text::int::<&str, extra::Default>(10).padded().map(|x: &str| x.parse::<u64>().unwrap());
// Parses a range like `0..4` into a vector like `[0, 1, 2, 3]`
let range = num.then_ignore(just("..")).then(num)
    .map(|(x, y)| x..y)
    .into_iter()
    .collect::<Vec<u64>>();
// Parses a list of numbers into a vector
let list = num.separated_by(just(',')).collect::<Vec<u64>>();
let set = range.or(list);
assert_eq!(set.parse("0, 1, 2, 3").unwrap(), [0, 1, 2, 3]);
assert_eq!(set.parse("0..4").unwrap(), [0, 1, 2, 3]);

use chumsky::prelude::*;

pub trait Parseable: Sized {
    fn parser<'src>() -> Boxed<'src, 'src, &'src str, Self>;
}

impl Parseable for i32 {
    fn parser<'src>() -> Boxed<'src, 'src, &'src str, Self> {
        todo().boxed()
    }
}

let user_input = user_input();
let mut parser = just('a').boxed();
for i in user_input {
    // Doesn't work due to type mismatch - since every combinator creates a unique type
    parser = parser.or(i).boxed();
}
let parser = parser.then(just('z'));
parser.parse("az").into_result().unwrap();

// Our parser can be in two modes depending on context: hexadecimal, or denary
#[derive(Clone)]
enum Mode { Hex, Dec }

let digits = one_of::<_, _, extra::Context<Mode>>("0123456789")
    .or(one_of("abcdef").contextual().configure(|cfg, ctx| matches!(ctx, Mode::Hex)))
    .repeated();

let num = just::<_, _, extra::Default>("0x").ignore_then(digits.with_ctx(Mode::Hex))
    // Fallback: when '0x' isn't present, parse using denary mode
    .or(digits.with_ctx(Mode::Dec))
    .to_slice();

assert_eq!(num.parse("0x1a3f5b").into_result(), Ok("0x1a3f5b"));
assert_eq!(num.parse("12345").into_result(), Ok("12345"));
// Without the '0x' prefix, hexadecimal digits are invalid
assert!(num.parse("1a3f5b").has_errors());

use chumsky::pratt::*;

let int = text::int::<_, extra::Err<Rich<char>>>(10)
    .from_str()
    .unwrapped()
    .padded();

let op = |c| just(c).padded();

let expr = int.pratt((
    prefix(2, op('-'), |_, x: i64, _| -x),
    infix(left(1), op('*'), |x, _, y, _| x * y),
    infix(left(1), op('/'), |x, _, y, _| x / y),
    infix(left(0), op('+'), |x, _, y, _| x + y),
    infix(left(0), op('-'), |x, _, y, _| x - y),
));

// Pratt parsing can handle unary operators...
assert_eq!(expr.parse("-7").into_result(), Ok(-7));
// ...and infix binary operators...
assert_eq!(expr.parse("6 + 3").into_result(), Ok(9));
// ...and arbitrary precedence levels between them.
assert_eq!(expr.parse("2 + 3 * -4").into_result(), Ok(-10));