# Type classes are for reusability

I see a certain overuse of typeclasses in Haskell libraries.
Type classes are not intended for massive re-use of some short identifier or in order to access some syntactic sugar
(e.g. do notation or number literals.
Instead type classes exist for writing reusable code.
Functions written using the `Num`

type class like polynomial multiplication work (almost) equally for `Int`

, `Integer`

, `Rational`

, `Float`

, `Double`

and custom number types.
Functions like `mapM`

and `replicateM`

that only need a `Monad`

constraint can be used for all monads including any combination of monad transformers.

Thus, think twice:

Do you really need a `Num`

instance for a network port, just in order to be able to write `80`

for a port number?
How would sensible definitions of `(+)`

would look like?
(Actually, it was not necessary to bundle the number literal feature expressed by the `fromInteger`

method
with the `(+)`

and `(*)`

operations,
and indeed NumericPrelude chooses a different set of operations.
But it is generally accepted that number literals are reserved for objects that allow some sort of arithmetics.)
Isn't `port 80`

even more comprehensible?

Do you really need a `Functor`

instance for the pair type?
What distinguishes the second member from the first member?
Is the generic pair type the right choice, or should it be better a custom type?

Do you really need a `Monad`

instance for writing something to a stream?
Or did you define the instance only for the do notation?
Ever considered a monoid instead?