Create Extension Method with No Parameters to Perform Associated Trait Method

[MasterTemple]

Hello, I've created (but not published) a crate called from_nested_tuple which lets me create structs from nested tuples
For example, I can say .map(FromTuple::from_tuple) instead of .map(|(((child1, child2), child3), child4)| Self { child1, child2, child3, child4, }).
However, I want to be able to say .from_tuple() instead of .map(FromTuple::from_tuple).

I am trying to use the extension feature.
I have read the documentation there, as well as for ExtParser, however I am still struggling to implement this.

Here is the trait:

pub trait FromTuple {
    type Tuple;
    fn from_tuple(tuple: Self::Tuple) -> Self;
}

it would look like

impl from_nested_tuple::FromTuple for WithNamedFields {
    type Tuple = ((char, char), char);
    fn from_tuple(tuple: Self::Tuple) -> Self {
        let ((a, b), c) = tuple;
        Self { a, b, c }
    }
}

when derived from

#[derive(FromTuple)]
struct WithNamedFields {
    a: char,
    b: char,
    c: char,
}

If I am not mistaken, the solution would look something like

pub trait ParserExt<'src, I, O, E>
where
    Self: Parser<'src, I, O, E>,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple(self) -> ?
    where
        Self: Sized,
        O: FromTuple<Tuple = I>,
    {
        self.map(FromTuple::from_tuple)
    }
}

but I am getting confused with all the parameters.

Can anyone help me with implementing this trait?
Also, what other steps would I need to do to create the chainable .from_tuple() method?

Thanks in advance!

[MasterTemple]

I think I figured it out (it works, but perhaps my solution is unorthodox).

pub trait FromTupleExt<'src, I, O, E>
where
    Self: Parser<'src, I, O, E>,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple<N>(self) -> impl Parser<'src, I, N, E>
    where
        Self: Sized,
        N: FromTuple<Tuple = O>,
    {
        self.map(FromTuple::from_tuple)
    }
}

impl<'src, I, O, E, T> FromTupleExt<'src, I, O, E> for T
where
    T: Parser<'src, I, O, E>,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple<N>(self) -> impl Parser<'src, I, N, E>
    where
        Self: Sized,
        N: FromTuple<Tuple = O>,
    {
        self.map(FromTuple::from_tuple)
    }
}

[MasterTemple]

I was trying to create a recursive parser and then I ran into errors like

2. rustc: the trait bound `impl chumsky::Parser<'_, &str, ParentElement<'_>>: Clone` is not satisfied
   required for `Map<impl Parser<'_, &str, ParentElement<'_>>, ParentElement<'_>, ...>` to implement `Clone`
   2 redundant requirements hidden
   required for `Or<Or<Map<impl Parser<'_, &str, ...>, ..., ...>, ...>, ...>` to implement `Clone`
   the full name for the type has been written to '/home/dgmastertemple/Dropbox/Development/rust/chumxl/target/debug/deps/chumxl-c2e27feba6f66f44.long-type-16090474991941434665.txt'
   consider using `--verbose` to print the full type name to the console [E0277]

I tried to add + Clone to my parsers as suggested in discussion #629, but that didn't work on any of my parsers that used my from_tuple method.
I would continue to get errors like below:

1. rustc: the trait bound `impl chumsky::Parser<'_, &'a str, TagName<'a>>: Clone` is not satisfied
   the trait `Clone` is not implemented for `impl chumsky::Parser<'_, &'a str, TagName<'a>>` [E0277]

I realized that I could not use my from_tuple method because the parser it returned did not impl Clone, but it could be inferred if I said .map(FromNestedTuple::from_nested_tuple).

I tried updating the trait signature, and it worked.

pub trait FromTupleExt<'src, I, O, E>
where
    Self: Parser<'src, I, O, E> + Clone,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple<N>(self) -> impl Parser<'src, I, N, E> + Clone
    where
        Self: Sized,
        N: FromNestedTuple<Tuple = O>,
    {
        self.map(FromNestedTuple::from_nested_tuple)
    }
}

impl<'src, I, O, E, T> FromTupleExt<'src, I, O, E> for T
where
    T: Parser<'src, I, O, E> + Clone,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple<N>(self) -> impl Parser<'src, I, N, E> + Clone
    where
        Self: Sized,
        N: FromNestedTuple<Tuple = O>,
    {
        self.map(FromNestedTuple::from_nested_tuple)
    }
}

However, I don't think it is appropriate for me to force all input parsers to impl Clone.
I think I would need some kind of containing struct like Map, where I can say impl<A: Clone, OA, F: Clone> Clone for Map<A, OA, F>.
I've spent many hours trying to implement Parser, ExtParser, and so on, but I feel like I'm stumbling around in the dark.
I would greatly appreciate any guidance here.
Thank you!

[zesterer]

I think this requirement comes from the fact that recursive requires the parser to be Clone too. This was a conservative requirement that isn't strictly needed, so I'm happy to see it removed if you'd like!

[MasterTemple]

Oh interesting, if removing it is a good idea, then perhaps it is worth doing.
I was able to figure out how to satisfy the clone requirement:

pub type MapFromTuple<A, N> = Ext<MapFromTuple_<A, N>>;

pub struct MapFromTuple_<A, N> {
    pub(crate) parser: A,
    _new: EmptyPhantom<N>,
}

impl<A: Copy, N> Copy for MapFromTuple_<A, N> {}
impl<A: Clone, N> Clone for MapFromTuple_<A, N> {
    fn clone(&self) -> Self {
        Self {
            parser: self.parser.clone(),
            _new: self._new.clone(),
        }
    }
}

impl<'src, I, O, E, A, N> ExtParser<'src, I, N, E> for MapFromTuple_<A, N>
where
    I: Input<'src>,
    E: ParserExtra<'src, I>,
    A: Parser<'src, I, O, E>,
    N: FromNestedTuple<Tuple = O>,
{
    fn parse(
        &self,
        inp: &mut InputRef<'src, '_, I, E>,
    ) -> Result<N, <E as ParserExtra<'src, I>>::Error> {
        inp.parse((&self.parser).map(FromNestedTuple::from_nested_tuple))
    }
}

// Expose `from_tuple` as a chain-able method

pub trait FromTupleExt<'src, I, O, E>
where
    Self: Parser<'src, I, O, E> + Clone,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple<N>(self) -> MapFromTuple<Self, N>
    where
        Self: Sized,
        N: FromNestedTuple<Tuple = O>,
    {
        Ext(MapFromTuple_ {
            parser: self,
            _new: EmptyPhantom::new(),
        })
    }
}

impl<'src, I, O, E, T> FromTupleExt<'src, I, O, E> for T
where
    Self: Parser<'src, I, O, E> + Clone,
    I: Input<'src>,
    E: extra::ParserExtra<'src, I>,
{
    fn from_tuple<N>(self) -> MapFromTuple<Self, N>
    where
        Self: Sized,
        N: FromNestedTuple<Tuple = O>,
    {
        Ext(MapFromTuple_ {
            parser: self,
            _new: EmptyPhantom::new(),
        })
    }
}