Overload a function which takes a scalar or a list

Question

I want to implement a function called output which is overloaded for a scalar and a list:

• For a scalar x, it executes print x (output 3 should print 3)

• For a list x, it executes putStr . unlines . map show x (output [1, 2, 3] should print 1\n2\n3)

Currently, I have non-overloaded outputScalar and outputList, both of which work (playground):

module Main where

main :: IO ()
main = do
    outputScalar 3
    outputList [1, 2, 3]

outputScalar :: (Show a, Num a) => a -> IO ()
outputScalar = print

outputList :: (Show a, Num a) => [a] -> IO ()
outputList = putStr . unlines . map show

Now I'd like to group them together to the single output function, using overloading. I tried the code below (playground), but it doesn't even compile.

module Main where

main :: IO ()
main = do
    output 1
    output [1, 2, 3]

class Show a => Output a where
    output :: a -> IO ()

instance (Show a, Num a) => Output a where
    output :: a -> IO ()
    output = print

instance (Show a, Num a) => Output [a] where
    output :: [a] -> IO ()
    output = putStr . unlines . map show

How can I fix the code? Or is it impossible to do that in Haskell?

Answer 1

It can be done, but it requires turning on a bunch of compiler extensions with scary names.

{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}

instance {-# OVERLAPS #-} (Show a, Num a) => Output a where
    output = print

instance {-# INCOHERENT #-} (Show a, Num a) => Output [a] where
    output = putStr . unlines . map show

We need FlexibleInstances (that one is admittedly harmless, and you see it in production code fairly commonly) to allow instance heads that aren't concrete. Then we use UndecidableInstances and INCOHERENT to turn off all of the termination checking on instance resolution. Finally, OVERLAPS tells GHC not to complain about the fact that the two instances are both technically valid for lists.

With all of these Haskell safety checks thrown into the rubbish pile, instance resolution works the way you want it to in this example. But I strongly recommend you do not do this in production code. If the extension names "undecidable" and "incoherent" aren't enough to scare you off, just keep in mind that this is really not how typeclasses are supposed to work. This path only leads to pain, I promise.

Answer 2

Although this can be done as an overlapping instance, I would advise against this, these usually lead to more pain than it's worth.

You should ask yourself why you want this kind of overload in the first place. If the scalar- and list cases are manifestly different, which they kind of seem to be, then writing code that's polymorphic over them only leads to more confusing semantics. It's then better to just write separate outputScalar (or simply use print as-is) and outputList. If you find yourself needing both versions in the same function then you can always just pass a a -> IO () function to avoid code duplication (preferrably wrapped in some abstraction like newtype Printer a = ...).

Having separate functions means you don't need to worry about cramming them in a single class, which means you can easily generalise beyond lists:

outputMany :: (Foldable f, Show a) => f a
outputMany = putStr . unlines . map show . toList

On the other hand, if there is really a legitimate polymorphism case, then notions of list or even foldable shouldn't have such a special status. In this case, they should be only one instance amongst many. It sounds a lot like you want

class PrettyPrint a where
  pprint :: a -> IO ()

This should then have discrete instances, i.e.

instance PrettyPrint Int where pprint = print
instance PrettyPrint Double where pprint = print
...
instance PrettyPrint a => PrettyPrint [a] where
  pprint = mapM_ pprint

If you don't like the boilerplate of many primitive instances that do nothing but redirect to print, you can simply make that the default case:

{-# LANGUAGE DefaultSignatures #-}

class PrettyPrint a where
  pprint :: a -> IO ()
  default pprint :: Show a => a -> IO ()
  pprint = print

...and now the instances are mere heads

instance PrettyPrint Int

For custom types you could even derive them:

{-# LANGUAGE DeriveAnyClass #-}

data Foobar = Foobar { foo :: Int, bar :: Double }
  deriving (Show, PrettyPrint)

Answer 3

The problem is this: suppose I were to write

instance Num a => Num [a] where {- ...actual implementation is unimportant -}

Now, which of the following two instances should be chosen for calling output on an [Int]?

instance (Show a, Num a) => Output a where
instance (Show a, Num a) => Output [a] where

Both match, and it's not enough to just say "pick whichever one" -- they lead to different behavior! One results in a single line with square brackets and commas, and the other results in multiple lines. Of course instance Num a => Num [a] doesn't exist in the base libraries, but the compiler is not permitted to assume it will never be created by some other library that you import in another part of your program it can't see right now.

One simple solution is to simply expand the Output a instance so that none of the expanded instances match the Output [a] instance. Like this:

instance Show a => Output [a] where output = mapM_ print
instance Output Int where output = print
instance Output Integer where output = print
instance Output () where output = print
-- etc.

It is unfortunate that you must repeat the where output = print bit every time for the latter instances, but that can be eliminated using DefaultSignatures like this:

class Output a where
    output :: a -> IO ()
    default output :: Show a => a -> IO ()
    output = print

instance Show a => Output [a] where output = mapM_ print
instance Output Int
instance Output Integer
instance Output ()
-- etc.

You can go even one step further with TemplateHaskell; with a bit of work, you would be able to write something like this:

outputInstances '[Int, Integer, (){- , etc. -}]

Not sure I'd recommend going that far to remove duplication though.