Put closure inside a union

Question

I'm trying to implement a parser combinator in rust.

I have the following parser, which is built with no errors/warnings:

use std::char;

#[derive(Debug)]
enum ParseResult<T> {
    Success(T),
    Failure(&'static str),
}

fn pchar(char_to_match: char) -> impl Fn(&str) -> ParseResult<(&str, &str)> {
    move |string: &str| match string.get(0..1) {
        Some(found) => match found.chars().next().unwrap() == char_to_match {
            true => ParseResult::Success((found, string.get(1..).unwrap())),
            false => ParseResult::Failure("char didnt match"),
        },
        None => ParseResult::Failure("No more left to parse."),
    }
}

fn main() {
    println!("{:?}", ParseResult::Success(&3));
    println!("{:?}", pchar('s')("r"));
    println!("{:?}", (|(a, b)| (a, b))((2, 3)));
    let input_abc = "ABC";
    println!("{:?}", pchar('A')(input_abc));

Instead of returning a function (closure) from pchar, I want to return a Parser<T> which I have declared as:

union Parser<T> {
    func: dyn Fn(&str) -> ParseResult<(T, &str)>,
}

Then my second iteration of pchar can return a Parser<T> such as:

fn pchar2(char_to_match: char) -> Parser<&str> {
    Parser {
        func: |string: &str| match string.get(0..1) {
            Some(found) => match found.chars().next().unwrap() == char_to_match {
                true => ParseResult::Success((found, string.get(1..).unwrap())),
                false => ParseResult::Failure("char didnt match"),
            },
            None => ParseResult::Failure("No more left to parse."),
        },
    }
}

I get all sorts of warnings regarding lifetime parameters, size at compile-time and expected trait dyn Fn.

What do I need to learn to solve this issue?

Update: As per Aleksander Krauze's suggestion, I have updated it to use a Box.

struct Parser<T> {
    func: Box<dyn Fn(&str) -> ParseResult<(T, &str)>>,
}

fn pchar2(char_to_match: char) -> Parser<&'static str> {
    Parser {
        func: Box::new(move |string: &str| match string.get(0..1) {
            Some(found) => match found.chars().next().unwrap() == char_to_match {
                true => ParseResult::Success((found, string.get(1..).unwrap())),
                false => ParseResult::Failure("char didnt match"),
            },
            None => ParseResult::Failure("No more left to parse."),
        }),
    }
}

The error I get is that the lifetime of the variable string must outlive char_to_match.

Update 2: As per Aleksander Krauze's answer. Here is the final working version:

fn pchar2<'a>(char_to_match: char) -> Parser<'a, &'a str> {
    Parser {
        func: Box::new(move |string: &'a str| match string.char_indices().next() {
            Some((i, c)) => match c == char_to_match {
                true => ParseResult::Success((
                    string.get(..i + 1).unwrap(),
                    string.get(i + 1..).unwrap(),
                )),
                false => ParseResult::Failure("char didnt match"),
            },
            None => ParseResult::Failure("No more left to parse."),
        }),
    }
}

Answer 1

Following snippet should fix your lifetime errors. The main problem was that you tried to return &'static str, when it was only a subslice of string. Types here are a little complex, but you could try to simplify them if Parser wouldn't be generic over T (but have T = &'a str). I don't know however what is your more general usecase, so it might not be viable.

Note that even that this code compiles, it has a bug! In rust strings are UTF-8 encoded, so single character can take anywhere from 1 to 4 bytes. But when you slice &str you are giving bytes indexes. That could result in a panic at runtime if you would slice in the middle of a character.

#[derive(Debug)]
enum ParseResult<T> {
    Success(T),
    Failure(&'static str),
}

struct Parser<'a, T> {
    func: Box<dyn Fn(&'a str) -> ParseResult<(T, &'a str)>>,
}

fn pchar2<'a>(char_to_match: char) -> Parser<'a, &'a str> {
    Parser {
        func: Box::new(move |string: &'a str| match string.get(0..1) {
            Some(found) => match found.chars().next().unwrap() == char_to_match {
                true => ParseResult::Success((found, string.get(1..).unwrap())),
                false => ParseResult::Failure("char didnt match"),
            },
            None => ParseResult::Failure("No more left to parse."),
        }),
    }
}