Type constructor that lifts to functions is even a pretty intuitive (ahistorical) intuition for “functor”.

See this is exactly the point where FP fans lose the rest of us.

You asked. I'm happy to dissect it to your level, but I don't know what you may be familiar with, and if you're not comfortable with type functions, I'm going to have a hard time motivating the extra bits a functor has.

The List functor is a combination of the type function sending `T` to `List<T>` and the ... what do you want me to call it, a function function? implemented in Java as:

    static <T, S> Function<List<T>, List<S>> map(Function<T, S> f) {
      return (ts) -> {
        var ss = new ArrayList<S>();
        for (final var t : ts) ss.add(f.apply(t));
        return ss;
      };
    }

We call it as map(f).apply(ts). If we want to pass them both at once, we can rewrite the function so that it's not static, but it doesn't much change that it's a mapping operation.

But it's not the `map` method that's the important part, so much as the idea that we can (or want to; can't in Java) pass `List` to any function that needs a Functor, which can then use whatever `map` implementation that functor has, without knowing what actual type function it was given.

Really, I suspect it's neither the type constructor nor the map function that's the conceptual hurdle. It's abstracting over the type constructor; taking a type constructor as a parameter. You may have never used a language that supports that, or seen a need for it, and this may all seem like needless sophistry until you do.

It’s a type constructor that extends to functions. It’s a functor.