Haskell class instance

Question

It's my first exercise to understand the classes in Haskell. My problem is how to define the functions that I have declared in the class and how to test them by terminal ghci.

I explain step by step what I did:

type Point2d = (Int, Int)   -- point
type Vector2d = (Int, Int)   -- vector

data Shape = 
    Line       Point2d Point2d
    | Triangle Point2d Point2d Point2d
    deriving (Eq, Show)

class ClassShape s where
    name    :: s -> String
    perim   :: s -> Int               -- given a CShape calculates the perimeter
    move    :: s -> Vector2d -> s

Now, I declare s as ClassShape instance, by implementing the corresponding functions.

nameShape :: Shape s -> String
nameShape Line = "Line"
nameShape Triangle = "Triangle"

perimShape :: Shape s -> Int
perimShape Line a b = 999 -- ...
perimShape Triangle a b c = 999 -- ...

Here's my problem: how should I declare the functions? I just need to see an "example" to understand the concept.

The error that Haskell returns is:

`Shape' is applied to too many type arguments
In the type signature for `nameShape':
  nameShape :: Shape s -> String


`Shape' is applied to too many type arguments
In the type signature for `perimShape':
  perimShape :: Shape s -> Int

Then, how do I test the program on Haskell?

Thanks to all.

Answer 1

You're making a common confusion of early Haskell programmers: using two different things which work in related ways (sum types and classes) to do the same thing in two different ways. Thus there are two problems: the "little" problem (what does this error mean?) and the "big" problem (why is your code shaped like this?).

The Little Problem

You wrote Shape s when you meant to just write Shape. The way you have defined Shape, it has kind * (that is, it is a concrete type) rather than kind * -> *, which is the kind of adjectives -- things like "a list of" or "a pair of" which are abstract until you give them a concrete type to modify ("a list of strings" is concrete, "a list of" is abstract). When you write Shape s you are applying Shape as an adjective to a type variable s but it's not an adjective; it's a noun.

That is why you get the error:

`Shape' is applied to too many type arguments

Side note: you may be used to languages where the error message usually is not very well-related to the actual problem. In Haskell usually the compiler tells you exactly what is wrong, as it did in this case.

The Big Problem

Type classes are collections of unrelated types which can do the same things. The type class syntax passes an implicit context as a "constraint", this context can be implicit because it belongs to the type.

You may need to read that last paragraph a few times in a quiet corner. Basically I mean to say that you can do the same thing as a type class with a data constructor for the context:

data EqOrd s = EqOrdLib {getEq :: s -> s -> Bool, getCmp :: s -> s -> Ordering}

-- this is just provided to us as a primitive by Haskell
intEOL :: EqOrd Int
intEOL = EqOrdLib (==) compare

-- but we can then define things like this:
listEOL :: EqOrd x -> EqOrd [x]
listEOL (EqOrdLib base_eq base_cmp) = EqOrdLib list_eq list_cmp where
    list_cmp [] [] = EQ
    list_cmp (_:_) [] = GT
    list_cmp [] (_:_) = LT
    list_cmp (x:xs) (y:ys) = case base_cmp x y of
        LT -> LT
        GT -> GT
        EQ -> list_cmp xs ys
    list_eq xs ys = list_cmp xs ys == EQ

Now to use that sort of context, you would have to write explicitly:

quicksort :: EqOrd x -> [x] -> [x]
quicksort _ [] = []
quicksort lib (p:els) = quicksort lib lesser ++ [p] ++ quicksort lib greater
    where cmp = getCmp lib
          p_less_than x = cmp x p == LT
          p_gte x = not . p_less_than
          greater = filter p_less_than els
          lesser = filter p_gte els

See, we explicitly pass in this library of functions lib and explicitly pull out the comparison function cmp = getCmp lib.

Type classes allow us to implicitly pass the library of functions, by stating up-front that the type itself only has one such library. We pass the library as a "constraint", so instead of EqOrd x -> [x] -> [x] you write Ord x => [x] -> [x] with the "fat arrow" of constraints. But secretly it means "when you ask me to use the < function on two values of type x, I know implicitly what library to get that function from and will get that function for you."

Now: you have one type, Shape, so you don't need typeclasses. (Go back to the first paragraph above: Type classes are collections of unrelated types which can do the same things.

If you want to do type classes then instead of the sum-type for Shape, let's define n-dimensional vectors of different types:

class Vector v where
    (*.) :: (Num r) => r -> v r -> v r
    (.+.) :: (Num r) => v r -> v r -> v r
    norm :: (Num r, Floating r) => v r -> r
    -- another advantage of type classes is *default declarations* like: 
    (.-.) :: (Num r) => v r -> v r -> v r
    v1 .-. v2 = v1 .+. (-1 *. v2)

data V2D r = V2D r r deriving (Eq, Show)
instance Vector V2D where
    s *. V2D x y = V2D (s * x) (s * y)
    V2D x1 y1 .+. V2D x2 y2 = V2D (x1 + x2) (y1 + y2)
    norm (V2D x y) = sqrt (x^2 + y^2)

data V3D r = V3D r r r deriving (Eq, Show)
instance Vector V3D where
    s *. V3D x y z = V3D (s * x) (s * y) (s * z)
    V3D x1 y1 z1 .+. V3D x2 y2 z2 = V3D (x1 + x2) (y1 + y2) (z1 + z2)
    norm (V3D x y z) = sqrt (x^2 + y^2 + z^2)    

Then we can write things like:

newtype GeneralPolygon v r = Poly [v r] 

perimeter :: (Num r, Floating r, Vector v) -> GeneralPolygon v r -> r
perimeter (Poly []) = 0
perimeter (Poly (x : xs)) = foldr (+) 0 (map norm (zipWith (.-.) (x : xs) (xs ++ [x])))

translate :: (Vector v, Num r) => GeneralPolygon v r -> v r -> GeneralPolygon v r
translate (Poly xs) v = Poly (map (v .+.) xs)

Making Typeclasses Work For You

Now if you really want to, you can also unwrap your sum-type data declaration into a bunch of data declarations:

data Line = Line Point2d Point2d deriving (Eq, Show)
data Square = Square Point2d Point2d deriving (Eq, Show)
data Triangle = Triangle Point2d Point2d Point2d deriving (Eq, Show)

Now you can do something simple like:

class Shape s where
    perim :: s -> Int
    move  :: s -> Vector2d -> s

Although I should say, you'll run into a problem when you want to do square roots for perimeters (sqrt is in the Floating typeclass, which Int does not have functions for, you'll want to change Int to Double or something).

Answer 2

Note that nameShape function will not work, because there is no Shape s type defined. Remember that s is a type variable. Only if you have defined Shape s type constructor you can use them. You have defined Shape type in your definition but not Shape s. For defining instance of typeclass, you have to do something like this:

instance ClassShape Shape where
    name (Line _ _) = "Line"
    name (Triangle _ _ _) = "Triangle"
    perim (Line x y) = undefined -- Calculate perimiter using x and y
    perim (Triangle x y z) = undefined
    move (Line x y) = undefined
    move (Triangle x y z) = undefined

You have to fill the undefined with working parts.