Making unneeded conversions a no-op

Question

I'm writing a program which reads and writes images that supports multiple pixel types (i.e. RGB, CMYK, greyscale etc.). These pixel types can use different types of components, sort of like this:

class (Storable c) => PixelComponent c where
    blackWhite :: c -> (c, c)
    toInt :: c -> Int
    toRealFrac :: (RealFrac a) => c -> a
    fromComponent :: (PixelComponent a) => a -> c

instance PixelComponent CUChar where
    blackWhite x = (minBound x, maxBound x)
    toInt = id
    toRealFrac = fromIntegral
    fromComponent x = ???

instance PixelComponent CFloat where
    black = 0.0
    white = 1.0
    toInt = truncate
    toReal = id
    fromComponent x = ???

class (Storable pix) => Pixel pix where
    red :: pix c -> c
    green :: pix c -> c
    blue :: pix c -> c
    alpha :: pix c -> c
    luminance :: pix c -> c
    fromPixel :: (Pixel a) => a c -> pix c

The idea is that you should be able to do getPixel myImage (10, 23) :: RGB CUChar or getPixel myImage (10, 23) :: RGB CFloat depending on the pixel format you want. The problem is that I don't know how to implement fromComponent in an efficient manner. Essentially, I would like unnecessary conversions such as fromComponent (1 :: CUChar) :: CUChar and fromComponent (0.5 :: CFloat) :: CFloat to be no-ops. I guessing that I'll have to rely on optimizations in any case.

Note: This might not be a good design anyway so if someone has a better suggestion I'm open to this. I'd still like to know how to make this solution work.

I'm wondering if `fromComponent` should be part of a different, multi-parameter type class dependent on both `a` and `c`. Then it seems it would be easier to defined `fromComponent` to be `id` in the case when both `a` and `c` are `CUChar` or `CFloat`, etc. — ErikR, Feb 13 '14 at 07:50
@user5402: that approach would certainly work. I hate having to change a design to accommodate seemingly minor optimizations though. — John L, Feb 13 '14 at 08:23
Have you checked whether the compiler really doesn’t optimize them away already? — Joachim Breitner, Feb 13 '14 at 09:10
How would I check this? @user5402: Seems like a nice solution! — Emil Eriksson, Feb 13 '14 at 09:12
Compile with `-ddump-simpl` and read the Core – sorry, no easier way. — Joachim Breitner, Feb 13 '14 at 09:43
@user5402: Thinking some more about it, wouldn't I almost certainly need OverlappingInstances if I wanted to also make a generic instance? — Emil Eriksson, Feb 13 '14 at 12:08
Yeah - probably. Honestly I think you should try @JohnL's approach first. The `RULES` pragma is at the heart of many, many optimizations in the Haskell libraries - `bytestring`, `text`, `pipes`, `repa` - just to name a few, and it's worth learning about and how to use it. — ErikR, Feb 13 '14 at 18:07
Well, it seems less frowned upon than OverlappingInstances if I understand correctly. — Emil Eriksson, Feb 13 '14 at 20:50

score 6 · Accepted Answer · answered Feb 13 '14 at 08:22

I'd suggest that handle this the same way as GHC handles numeric conversions (e.g. fromIntegral), which is via rewrite rules.

If you look in GHC.Real, you find

-- | general coercion from integral types
fromIntegral :: (Integral a, Num b) => a -> b
fromIntegral = fromInteger . toInteger

{-# RULES
"fromIntegral/Int->Int" fromIntegral = id :: Int -> Int
    #-}

The default is a lot of round-tripping for integral types, but fortunately that never happens because there are RULEs for all library-provided integral types.

There are many more RULEs specified in GHC.Int for example to handle the rest of the conversions. You'll find a similar setup for other similar functions (e.g. realToFrac).

Now there's one major problem with your use-case, which is that it's often difficult for RULEs to match on class methods. There are two ways around this. The first is to define a common type (e.g. Integer in GHC's code), and provide class methods to convert to and from that type. Then write a general-purpose conversion function (e.g. fromIntegral), use that everywhere, and have your RULEs match on it.

The other approach is to do something like this:

instance PixelComponent CUChar where
    blackWhite x = (minBound x, maxBound x)
    toInt = id
    toRealFrac = fromIntegral
    {-# INLINE fromComponent #-}
    fromComponent = toCUChar

toCUChar :: PixelComponent a => a -> CUChar
toCUChar = ...

{-# RULES "fromComponent/CUChar->CUChar" toCUChar = id :: CUChar -> CUChar #-}

The former is what GHC does, so it's likely to work well. I've been using the latter approach recently and haven't had any issues though, so either one should work.

score 0 · Answer 2 · answered Feb 14 '14 at 03:16

Multi-parameter type classes might be your friend here, but keep in mind you're going to have to type out things n^2 times here.

Here's a trivial example, lets say we have separate types for lower case strings, upper case strings, and mixed strings. Obviously, converting a string to it's own type shouldn't require any work, nor should converting to a mixed string. Only conversions to an upper or lower string not from itself should require a conversion.

The code below (ideone) illustrates this approach:

{-# LANGUAGE MultiParamTypeClasses #-}

import Data.Char (toUpper, toLower)

data Lower = Lower String deriving Show
data Mixed = Mixed String deriving Show
data Upper = Upper String deriving Show

toUpperStr = map toUpper
toLowerStr = map toLower

class Make a where
  make :: String -> a

instance Make Lower where
  make s = Lower (toLowerStr s)

instance Make Mixed where
  make s = Mixed s

instance Make Upper where
  make s = Upper (toUpperStr s)

class Convert a b where
  convert :: a -> b

instance Convert Lower Lower where
  convert = id

instance Convert Lower Mixed where
  convert (Lower s) = Mixed s

instance Convert Lower Upper where
  convert (Lower s) = Upper (toUpperStr s)

instance Convert Mixed Lower where
  convert (Mixed s) = Lower (toLowerStr s)

instance Convert Mixed Mixed where
  convert = id

instance Convert Mixed Upper where
  convert (Mixed s) = Upper (toUpperStr s)

instance Convert Upper Lower where
  convert (Upper s) = Lower (toLowerStr s)

instance Convert Upper Mixed where
  convert (Upper s) = Mixed s

instance Convert Upper Upper where
  convert = id

main = print (convert ((make "Hello World") :: Lower) :: Upper)

Making unneeded conversions a no-op

2 Answers2