Using Cow<'a, str> as return type

[decipher3114]

Input Type

pub type StatefulInput<'input, 'state> = Stateful<LocatingSlice<&'input str>, ParseState<'state>>;

Literal Type

#[derive(Debug, Clone, PartialEq)]
pub enum Literal<'a> {
    String(Cow<'a, str>),
    Integer(i64),
    Decimal(f64),
    Boolean(bool),
}

impl<'a> Literal<'a> {
    pub(crate) fn parse(input: &mut StatefulInput) -> ModalResult<Literal<'a>> {
        alt((
            string::parse.map(Literal::String), // Error here
            decimal::parse.map(Literal::Decimal),
            integer::parse.map(Literal::Integer),
            boolean::parse.map(Literal::Boolean),
        ))
        .parse_next(input)
    }
}

Error

error[E0599]: the method `map` exists for fn item `fn(&mut Stateful<LocatingSlice<&str>, ParseState<'c>>) -> ... {parse}`, but its trait bounds were not satisfied
  --> crisp\src\literal\mod.rs:26:27
   |
26 |             string::parse.map(Literal::String),
   |                           ^^^ method cannot be called due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `<for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse} as std::ops::FnOnce<(&mut _,)>>::Output = std::result::Result<_, _>`
           which is required by `for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse}: winnow::Parser<_, _, _>`
           `<&for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse} as std::ops::FnOnce<(&mut _,)>>::Output = std::result::Result<_, _>`
           which is required by `&for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse}: winnow::Parser<_, _, _>`
           `<&mut for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse} as std::ops::FnOnce<(&mut _,)>>::Output = std::result::Result<_, _>`
           which is required by `&mut for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse}: winnow::Parser<_, _, _>`
           `for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse}: std::iter::Iterator`
           which is required by `&mut for<'a, 'b, 'c> fn(&'a mut winnow::Stateful<winnow::LocatingSlice<&'b str>, state::ParseState<'c>>) -> std::result::Result<std::borrow::Cow<'a, str>, winnow::error::ErrMode<winnow::error::ContextError>> {literal::string::parse}: std::iter::Iterator`
help: use parentheses to call this function
   |
26 |             string::parse(/* &mut winnow::Stateful<winnow::LocatingSlice<&str>, state::ParseState<'_>> */).map(Literal::String),
   |                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

[decipher3114]

Just observed that whenever the input: &mut StatefulInput requires an explicit lifetime for the mut, map throws error.

[epage]

It should at least be

#[derive(Debug, Clone, PartialEq)]
pub enum Literal<'a> {
    String(Cow<'a, str>),
    Integer(i64),
    Decimal(f64),
    Boolean(bool),
}

impl<'a> Literal<'a> {
    pub(crate) fn parse(input: &mut StatefulInput<'a, '_>) -> ModalResult<Literal<'a>> {
        alt((
            string::parse.map(Literal::String), // Error here
            decimal::parse.map(Literal::Decimal),
            integer::parse.map(Literal::Integer),
            boolean::parse.map(Literal::Boolean),
        ))
        .parse_next(input)
    }
}

The input's lifetime needs to typed to the Literal lifetime.

If that is still causing an error like this, I'll likely need a reproduction case to help further.

[epage]

btw you most likely need something like

#[derive(Debug, Clone, PartialEq)]
pub enum Literal<'a> {
    String(Cow<'a, str>),
    Integer(i64),
    Decimal(f64),
    Boolean(bool),
}

impl<'a> Literal<'a> {
    pub(crate) fn parse<'i, 's>(input: &'i mut StatefulInput<'a, 's>) -> ModalResult<Literal<'a>> {
        alt((
            string::parse.map(Literal::String), // Error here
            decimal::parse.map(Literal::Decimal),
            integer::parse.map(Literal::Integer),
            boolean::parse.map(Literal::Boolean),
        ))
        .parse_next(input)
    }
}

I've generally found that once lifetimes are involved, you have to explicitly state your mutable-ref lifetime.