What does the star mean in this haskell code?

Question

I found this code in the unm-hip package. So Pixel is a function ?

class Imageable i where
  type Pixel i :: *
  rows :: i -> Int
  cols :: i -> Int
  ref  :: i -> Int -> Int -> (Pixel i)
  makeImage :: Int -> Int -> PixelOp (Pixel i) -> i
  pixelList :: i -> [Pixel i]
  pixelList i = [ ref i r c | r <- [0..(rows i - 1)], c <- [0..(cols i - 1)]]

Answer 1

As an extension to standard Haskell, you can deal with "kinds". Kinds are sort of a very basic type system for types and type constructors. Kind * is a simple type, like Int. Kind * -> * is a type constructor that takes a type and yields a type, like Maybe: pass it a type like Int as an argument, and you get the type Maybe Int.

The other extension used in this code (which I didn't notice at first, since the indentation was lost) is associated types. A typeclass in standard Haskell can specify a number of functions that the type must support. With associated types, it can additionally specify types and type constructors that are associated with the type.

Here, this means that a type i that is an instance of Imageable (i.e. behaves like an image) must have an associated pixel type Pixel i, and this must be a simple type (kind *), not a type constructor.

Answer 2

"So Pixel is a function?"

Pixel is a type-level function. It takes a single type (which must be an instance of Imageable) and returns a type of kind '*'. Based on it's usage in the example code, the input type must also be of kind '*'. So, Pixel is very much like Maybe, they are both "type constructors" of kind '* -> *', you provide them a "simple type" and they return a "simple type". They are also valid in the same locations. Just like you can't have a function of type 'Foo -> Maybe', you also won't be able to have a function of type 'Bar -> Pixel'.