How to code polymorphic functions under Haskell 98

Question

As a training exercise, I have written a polymorphic function to determine whether a given number is prime to either a single number or all of a list of numbers:

{-# LANGUAGE FlexibleInstances #-}
class PrimeTo a where
    ispt :: Integer -> a -> Bool
instance PrimeTo (Integer) where
    ispt n d = 0 /= (rem n d)
instance PrimeTo ([Integer]) where
    ispt n [] = True
    ispt n (x:xs) = (ispt n x) && (ispt n xs)

To get this to work, I had to use FlexibleInstances, and I'm happy with that, but curious.

Under strict Haskell 98, as I understand it, I would need to add a type descriptor, T, to the instance definitions:

class PrimeTo a where
    ispt :: Integer -> a -> Bool
instance PrimeTo (T Integer) where
    ispt n d = 0 /= (rem n d)
instance PrimeTo (T [Integer]) where
    ispt n [] = True
    ispt n (x:xs) = (ispt n x) && (ispt n xs)

but I haven't a clue what goes in place of "T", and I don't even know whether this is possible under Haskell 98.

So:

Is this even possible under Haskell 98?
If so, what would be used for T?

FYI, the instance for `[Integer]` can be simplified to `ispt = all . ispt`. — chepner, Jul 05 '20 at 13:31

chi · Accepted Answer · 2020-07-05T13:30:57.003

T can be Integer or [], as folllows:

class PrimeTo a where
    ispt :: Integer -> a -> Bool
instance PrimeTo Integer where
    ispt n d = 0 /= (rem n d)
instance PrimeToList a => PrimeTo [a] where
    ispt = isptList  -- see below

Since the last one can only be about [a], we need a helper class PrimeToList. Here's the additional helper class and instance:

class PrimeToList a where
    isptList :: Integer -> [a] -> Bool

instance PrimeToList Integer where
    isptList n []     = True
    isptList n (x:xs) = ispt n x && isptList n xs

By the way, I'd rewrite the last definition using all:

    isptList n = all (ispt n)

The above shows the general technique. In your specific case, you can probably avoid the helper class and use

class PrimeTo a where
    ispt :: Integer -> a -> Bool
instance PrimeTo Integer where
    ispt n d = 0 /= (rem n d)
instance PrimeTo a => PrimeTo [a] where
    ispt n = all (ispt n)

This will also define PrimeTo [[Integer]], PrimeTo [[[Integer]]] and so on, so it is not a perfect replacement like the previous one.

The previous one also defines those instances—with unsatisfiable constraints. — dfeuer, Jul 08 '20 at 00:04

How to code polymorphic functions under Haskell 98

1 Answers1