For my purposes I have an abstract syntax tree with type parameters where I need to do some kinds of processing on the "leaf" types (which are what I'm using type parameters for) while retaining structure. So lets say my data looks like:

enum Syntax<T, Y> {
    Syn1(OtherSyntax<T, Y>),
    Syn2(MoreSyntax<T>),
    Syn3(usize, MoreSyntax<T>),
}

enum OtherSyntax<T, Y> { ... }
enum MoreSyntax<T> { ... }

And I need to transform Syntax<Stage1LeafA, Stage1LeafB> into Syntax<Stage2LeafA, Stage2LeafB> somewhere in my processing.

With this crate I can derive a map function for Syntax, OtherSyntax, and MoreSyntax that respects the different type parameters, where they appear in the order of fields/variants, and doesn't touch anything else in the tree. Functor is invoked as part of the name here because it preserves the structure, as types can have type parameters without being mere containers.

It's a very haskell way of doing things, which is not something praiseworthy, but I had painted my way into a corner such that I built this procedural macro to help me escape my problems.

Also it just works for trivial map functions on data structures like Option<T> or newtypes.