Haskell class instance

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).