Why does parametrized type instance works without specifying type parameter

Question

When having a parametrized type: data A a=X a| Y

I have tried (successfully) implementing Functor and Applicative without specifiying the type parameter:

instance Functor A where instead of instance Functor (A a) where.
Why does it work ?

Looking in LYAH it seems all examples specify the type parameter in all their typeclass instances. When should you neglect the type parameter ?

Conjuration

The type signature of fmap (in Functor is fmap :: (a -> b) -> f a -> f b, so here we apply a to the type constructor A, given that we would make A Int a functor, how should we hande f a (so A Int a)? – Immolate

The type parameter is thus not "neglected", Here f is basically a function that takes a type and constructs a new type. – Immolate

When using instance Functor A where its like we partially apply A ? and we supply the type when we call fmap ? (Not sure if i understood) – Conjuration

@BercoviciAdrain: exactly, f is a "function" that transforms a type (like Int) into a type A Int. – Immolate

But then it means that if we specify in the instance A [something] and we call fmap A [something_else] it crashes . Does it mean that in the instance implementation we can fill any type parameter or let it free: Ex: instance T a b c where , instance T Int b c ,instance T Int b Int ..etc? – Conjuration

we just pass a function that constructs a type. The type class itself can then "construct types". For example it could have done something like otherfmap :: (Int -> String) -> f Int -> f String, so the parameter is not per se free, but for Functor, yes it is free. – Immolate

By function you mean the type constructor ? – Conjuration

yes, but well a type constructor is a function on the "type level", just like a data constructor is a function on the "instance level". – Immolate

Answer 1

instance Functor A where instead of instance Functor (A a) where. Why does it work ?

I find this easier to understand using GHC's kinding system. Let's start from a simple case, and experiment in GHCi:

> :k Eq Int
Eq Int :: Constraint

This tells us that Eq Int is a constraint, some property that might be verified during type checking. Indeed, if we type check (12 :: Int) == (42 :: Int), the compiler will verify that integers can be compared, resolving the constraint Eq Int.

What is Eq alone, the name of the class without the Int parameter?

> :k Eq
Eq :: * -> Constraint

This tells us that Eq can be thought of a function from types (* is the kind of types) to constraint.

Indeed, in Eq Int, Int is a type, so we have Int :: * making Int a well-kinded argument to pass to Eq.

Enough of type classes, what about type constructors?

> :k Maybe Int
Maybe Int :: *

No surprise, Maybe Int is a type

> :k Maybe
Maybe :: * -> *

Maybe instead, is a function from types to types (*->*). This is indeed what the Maybe type constructor does: mapping a type (Int) to a type (Maybe Int).

Back to the original question. Why can't we write instance Functor (A a) but we can instead write instance Functor A? Well, we have that

> :k A Int
A Int :: *
> :k A
A :: * -> *

and, most importantly,

> :k Functor
Functor :: (* -> *) -> Constraint

This tells us the the kind of the Functor type class is not the same kind of the Eq type class. Eq expects a type as an argument, while Functor expects something of kind (* -> *) as an argument. A fits that kind, while A Int does not.

This happens when, in the definition of the class, the argument is applied to some other type. E.g.

class C1 a where
   foo :: a -> Bool

results in C1 :: * -> Constraint. Instead,

class C2 f where
   bar :: f Int -> Bool

results in C2 :: (* -> *) -> Constraint, since f is not itself used as a type, f Int is, so f must be a parameterized type of kind * -> *.

Doorn

Answer 2

When should you neglect the type parameter?

The type parameter is not "neglected". Let us first take a look at the Functor type class:

class Functor f where
    fmap :: (a -> b) -> f a -> f b

Notice the f a and f b in the type signature. We thus here "construct types" for the type signature of fmap.

Here f is thus basically a function that takes a type and transforms it into a type. For example if f ~ A if a ~ Int, then f a generates the A Int type.

Learn You a Haskell for the Greater Good! actually explains this in its chapter about Functors, Applicatives and Monoids:

Many times, we want to make our types instances of certain type classes, but the type parameters just don't match up for what we want to do. It's easy to make Maybe an instance of Functor, because the Functor type class is defined like this:

class Functor f where  
    fmap :: (a -> b) -> f a -> f b 

So we just start out with:

  instance Functor Maybe where

And then implement fmap. All the type parameters add up because the Maybe takes the place of f in the definition of the Functor type class and so if we look at fmap like it only worked on Maybe, it ends up behaving like:

fmap :: (a -> b) -> Maybe a -> Maybe b

(...)

Immolate