Relation Between the Different Types in Haskell

Question

From my understanding, there are 4 "types" in Haskell:

• Algebraic data type with data
• Data type constructors (what's after the = in the data types; not types technically, I don't think)
• Type alias with type
• Typeclasses with class
• Type instances with instance

The questions are:

1. If there are more kinds of types in Haskell. If so, what there relations are.
2. What the difference is between a data type and a class typeclass. They seem similar, though obviously they have some different features. Same with (3).
3. What the difference is between a data type and a instance typeclass instance.

I am new to Haskell.

Answer 1

data and newtype introduce new types (or type constructors actually - Maybe isn't a type, but Maybe a is a type for any a that is a type).

A data declaration introduces both a new type (what's left of the =) and a way to represent data of that type (what's right of the =).

So for example, if you have a data declaration like this:

data SomeType = SomeConstructor

Then you have introduced a new type called SomeType, and a way to construct values of SomeType, namely the constructor SomeConstructor (which incidentally doesn't have any parameters, so is the the only value inhabiting this type).

A typeclass doesn't do either of these things (and neither does an instance). A typeclass introduces a constraint and a bunch of polymorphic functions that should be available if that constraint is met. An instance is basically saying "this type meets this constraint" by providing an implementation for these functions. So a class isn't really introducing new types, it's just a way to provide ad-hoc polymorphism for existing types.

For instance, the Show typeclass is roughly this:

class Show a where -- a is an instance of Show if
   show :: a -> String -- it has a function called show with this signature

(Note that the actual Show class in Prelude doesn't quite look like this)

show now has the type Show a => a -> String, which you can read as

for all a, if they meet the constraint Show (or alternatively, if they are an instance of Show) this is a function that takes an a and returns a string

An instance for this would look like this

instance Show SomeType where
  show SomeConstructor = "SomeConstructor"

Which means

SomeType satisfies the constraint Show, and I'll show you how by providing an implementation of show

That's roughly the gist of it. There are language extensions that allow somewhat more involved things to happen with type classes and instances, but you don't need to worry about that for now.