Pfthb

I am trying to use show function to print to the console value of zer or one, but I can not do it. Here is my code:

-# LANGUAGE NoMonomorphismRestriction #-

import Control.Arrow
import Data.List
import qualified Data.Map as M
import Data.Function

class Eq a => Bits a where
 zer :: a
 one :: a

instance Bits Int where
 zer = 0
 one = 1

instance Bits Bool where
 zer = False
 one = True

instance Bits Char where
 zer = '0'
 one = '1'

I am trying to use function show to convert zer or one to the string.
So I tried it:

k = zer
show k

but I got this error

<interactive>:10:1: error:
 • Ambiguous type variable ‘a0’ arising from a use of ‘show’
 prevents the constraint ‘(Show a0)’ from being solved.
 Probable fix: use a type annotation to specify what ‘a0’ should be.
 These potential instances exist:
 instance (Show k, Show a) => Show (M.Map k a)
 -- Defined in ‘containers-0.5.7.1:Data.Map.Base’
 instance Show Ordering -- Defined in ‘GHC.Show’
 instance Show Integer -- Defined in ‘GHC.Show’
 ...plus 24 others
 ...plus 11 instances involving out-of-scope types
 (use -fprint-potential-instances to see them all)
 • In the expression: show zer
 In an equation for ‘it’: it = show zer

so i tried to create instance for show. So I added this to my code:

instance (Show a) => Show (Bits a) where
 show zer = "0"
 show one = "1"

But I got another error

main.hs:25:28: error:
 • Expected a type, but ‘Bits a’ has kind ‘Constraint’
 • In the first argument of ‘Show’, namely ‘Bits a’
 In the instance declaration for ‘Show (Bits a)’

Can you tell me what I am doing wrong?

You're trying to make a class an instance of a class, rather than making a type an instance of a class. Compare:

Show a => Show (Bits a) -- Invalid

to

Show a => Show (Maybe a) -- Valid

where Maybe is a datatype whereas Bits is a class name.

I don't think it's possible to express "anything that has a Bits instance has a Show instance", because it can lead to overlapping instances: if you could define something like that, then when you use show :: Int -> String the compiler wouldn't know whether to use the Prelude's instance of Show Int or the show that would be defined by Int being an instance of Bits.

A messy workaround could be to enforce "the other direction": that every instance of Bits must be an instance of Show, which would allow you to use a's Show instance rather than your own one:

class (Show a, Eq a) => Bits a where
 zer :: a
 one :: a

main = print (zer :: Int)

although this requires an explicit type signature to resolve the ambiguity in the type of zer at the call site.