Haskell generic type parameters resolver tool or method

Question

Let's look at these functions' types for example:

:t traverse
traverse
  :: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b)

:t id
id :: a -> a

They have no concrete types, but have generic type parameters: a, f, b, t (correct me if they called not generic type parameters please)

If I combine id and traverse together in this way,

:t traverse id [Just 1, Just 2, Nothing] 
traverse id [Just 1, Just 2, Nothing] :: Num b => Maybe [b]

Haskell can now bind some concrete types for the type variables a, f, b, t.

t = []
a = Maybe bb
f = Maybe
b = Num bb => bb

Below I infer the types and mappings to parameters by hand, is there any way or tool in Haskell to do this automatically, so that it takes some composed parts (id and traverse) in an example, extracts their type signatures in general, and on output produces a mapping from generic type parameters names to concrete inferred types?

See also the first example here: https://wiki.haskell.org/Type_inference for expression "map ord" on how Haskell finds bindings of actual types to names.

So when we look at functions separately we only have names a, f, b, t. But then we combine the functions and provide some extra information like [Just 1, Just 2, Nothing], and the names a, f, b, t are mapped to concrete types.

I want to catch and show this mapping automatically.

Answer 1

I think f and t are more generic type constructor parameters, as they act on a type to give you a type (they kind is * -> *, where * means "a concrete type").

traverse id is not composition, it is function application, as you are passing id as an argument to traverse. this . that is function composition between this and that, in the mathematical sense, where you create a function that gives its (first) argument as an input to that and feeds the result of this application to this.

You refer to the example in this page, where given this

map :: (a -> b) -> [a] -> [b]
Char.ord :: (Char -> Int)

the compiler is able to deduce that the type of map ord is [Char] -> [Int], as you can check yourself by writing :t map ord at the command line.

If you expect a similar output with concerete types when you type :t traverse id, you won't get it, for the simple reason that traverse id is still a polymorphic function, both in its concrete type arguments and type constructor arguments.

Just to give a slightly different example, if you type :t traverse (:[]), where (:[]) has type a -> [a], which is a particular case of the (Applicative f) => a -> f b that traverse expects, you get this output,

traverse (:[]) :: Traversable t => t b -> [t b]

which, compared with :t traverse,

traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

tells you that traverse, in traverse (:[]), has been "instantiated" with f === [] and a === b.