# 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 like `fmap`

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 Numeric Prelude 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 better be 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? Please, give the monoid a try!