Inferring constraints with polymorphic recursion

EvalPolyRec.hs

module EvalPolyRec where

import Prelude hiding (seq)

class Eval a where
  seq :: a -> b -> b

instance Eval (a,b) where
  seq (_, _) = id

data SP a b = SP !a !b

instance (Eval a, Eval b) => Eval (SP a b) where
  seq (SP a b) = a `seq` b `seq` id

szip :: [a] -> [b] -> [SP a b]
szip (a : as) (b : bs) = SP a b : szip as bs
szip _ _ = []

f :: Eval a => [a] -> ()
f [] = ()
f (x : xs) = x `seq` f (zip xs xs)

g :: Eval a => [a] -> ()
g [] = ()
g (x : xs) = x `seq` f (szip xs xs)

Not a commentary on the code, I'm just bored

class Eval a where
  seq :: a -> (forall x. x -> x)

instance Eval (a, b) where
  seq :: (a, b) -> (forall x. x -> x)
  seq (_, _) = id -- @x

...

-- @ is good for showing polymorphic recursion
f :: forall a. Eval a => [a] -> ()
f []     = ()
f (x:xs) = x `seq` f @(a, a) (zip xs xs)

g :: forall a. Eval a => [a] -> ()
g []     = ()
g (x:xs) = x `seq` f @(SP a a) (szip xs xs) 

Should that last f be a g?