Haskell type class instance syntax

Your question is a bit unclear, but I assume you're asking why you have to use e in instance Functor (MayFail e) instead of just writing instance Functor MayFail.

This is because Functor takes a type parameter of kind Type -> Type, and MayFail on its own would have kind Type -> Type -> Type. (Using MayFail e a would also be wrong, as its kind is just Type.)

MayFail :: Type -> Type -> Type is not a functor, but a bifunctor:

-- somewhat simplified definition
class Bifunctor p where
    -- p :: Type -> Type -> Type
    bimap :: (a -> c) -> (c -> d) -> p a b -> p c d

instance Bifunctor MayFail where
    bimap f _ (Error e) = Error (f e)
    bimap _ g (Result x) = Result (g x)

But, for any fixed error type e, the result of the partial application MayFail e :: Type -> Type is a functor:

instance Functor (MayFail e) where
    fmap _ (Error e) = Error e
    fmap f (Result x) = Result (f x)
    -- Or, using the Bifunctor instance,
    -- fmap = bimap id

In some sense, a bifunctor is a mapping of types to functors.

The Functor class is defined as

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

That is, the type constructor f must accept a single type argument (otherwise f a and f b in the type signature of fmap would be invalid).

Formally this means f must have kind Type -> Type (also known as * -> * in older versions of GHC).

This is different from e.g. Eq or Show, which look like this (simplified):

class Eq a where
    (==) :: a -> a -> Bool

class Show a where
    show :: a -> String

Here the parameter a is used as a type itself.

Your type, data MayFail e a, has two parameters. If we were to plug just MayFail into the Functor definition, as in

instance Functor MayFail where ...

this would implicitly declare fmap as

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

which is a kind error: MayFail a is not a type because MayFail takes two arguments.

Similarly, if we tried

instance Functor (MayFail x y) where ...

then fmap would end up having the type

fmap :: (a -> b) -> MayFail x y a -> MayFail x y b

which is also a kind error: MayFail only takes two arguments, not three.

The only way to form a sensible type signature is to set f = MayFail e, because then f a becomes MayFail e a (and f b becomes MayFail e b), which is well-formed.