Why can I print a tuple with 5 elements but not with 6 in Haskell?

Question

I tried printing the following tuple

(1,2,3,4,5,6)

which gave me the following error

ERROR - Cannot find "show" function for:
*** Expression : (1,2,3,4,5,6)
*** Of type    : (Integer,Integer,Integer,Integer,Integer,Integer)

But if I try it with the following tuple

(1,2,3,4,5)

everything works like a charm.

My guess is that Haskell only defines Show for tuples up to five elements (since a tuple of with 5 elements is apparently another type than a tuple with 6 elements). But somehow I am to stupid to find proof for that.

So my question is:

Why is this so, and how can I print a tuple with 6 elements (since it seems that I cannot put tuples in the head of an instance definition)?

Edit: I'm using Hugs

Answer 1

Here you go. Include this instance of Show for a 6-tuple

-- Tuples   -- for ref, def'n from the Prelude
{-
instance  (Show a, Show b) => Show (a,b)  where
  showsPrec p (x,y) = showChar '(' . shows x . showChar ',' .
                                   shows y . showChar ')'


instance  (Read a, Read b) => Read (a,b)  where
    readsPrec p       = readParen False
                        (\r -> [((x,y), w) | ("(",s) <- lex r,
                                             (x,t)   <- reads s,
                                             (",",u) <- lex t,
                                             (y,v)   <- reads u,
                                             (")",w) <- lex v ] )
-}
-- Other tuples have similar Read and Show instances

instance  (Show a, Show b, Show c, Show d, Show e, Show f) 
      => Show (a,b,c,d,e,f)  where
  showsPrec p (x1,x2,x3,x4,x5,x6) = showChar '(' . shows x1 . showChar ',' .
                                   shows x2 . showChar ',' . 
                                   shows x3 . showChar ',' .
                                   shows x4 . showChar ',' .
                                   shows x5 . showChar ',' .
                                   shows x6 . showChar ')'

Answer 2

Here is my test on ghci

Prelude> (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,5 1,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100)

<interactive>:445:1:
    A 100-tuple is too large for GHC
      (max size is 62)
      Workaround: use nested tuples or define a data type

However, for printing 15 is the limit

Prelude> (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16)

<interactive>:450:1:
    No instance for (Show
                       (t0,
                        t1,
                        t2,
                        t3,
                        t4,
                        t5,
                        t6,
                        t7,
                        t8,
                        t9,
                        t10,
                        t11,
                        t12,
                        t13,
                        t14,
                        t15))
      arising from a use of `print'
    Possible fix:
      add an instance declaration for
      (Show
         (t0,
          t1,
          t2,
          t3,
          t4,
          t5,
          t6,
          t7,
          t8,
          t9,
          t10,
          t11,
          t12,
          t13,
          t14,
          t15))
    In a stmt of an interactive GHCi command: print it

Answer 3

Don't use Hugs.

It hasn't been maintained for years, and doesn't support half the stuff that a modern Haskell implementation is supposed to support. (Hugs supports "most of" Haskell '98, which is the previous revision of the language specification.)

You will probably find example code on the Internet that works perfectly with GHC, but fails miserably with Hugs. You will spend ages trying to figure out why your code doesn't work, only to eventually realise "oh, it does work — just not with Hugs".