在haskell中显示约束类型

Question

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?

Answer 1

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.