more uniform treatment of Read1/Show1/Read2/Show2
authorRoss Paterson <ross@soi.city.ac.uk>
Wed, 16 Dec 2015 13:48:26 +0000 (13:48 +0000)
committerRoss Paterson <ross@soi.city.ac.uk>
Wed, 16 Dec 2015 13:48:26 +0000 (13:48 +0000)
Now there are two methods in each class, corresponding to the methods
in the basic classes, and each of the lifting functions takes pairs of
function arguments.  The lifting functions (which have not appeared in
any release) are renamed from xxxWith to liftXxx, to avoid a clash with
showListWith (from Text.Show).

15 files changed:
Control/Applicative/Backwards.hs
Control/Applicative/Lift.hs
Control/Monad/Trans/Error.hs
Control/Monad/Trans/Except.hs
Control/Monad/Trans/Identity.hs
Control/Monad/Trans/List.hs
Control/Monad/Trans/Maybe.hs
Control/Monad/Trans/Writer/Lazy.hs
Control/Monad/Trans/Writer/Strict.hs
Data/Functor/Classes.hs
Data/Functor/Compose.hs
Data/Functor/Constant.hs
Data/Functor/Product.hs
Data/Functor/Reverse.hs
Data/Functor/Sum.hs

index b90452f..967de37 100644 (file)
@@ -38,18 +38,18 @@ import Data.Traversable
 newtype Backwards f a = Backwards { forwards :: f a }
 
 instance (Eq1 f) => Eq1 (Backwards f) where
-    eqWith eq (Backwards x) (Backwards y) = eqWith eq x y
+    liftEq eq (Backwards x) (Backwards y) = liftEq eq x y
 
 instance (Ord1 f) => Ord1 (Backwards f) where
-    compareWith comp (Backwards x) (Backwards y) = compareWith comp x y
+    liftCompare comp (Backwards x) (Backwards y) = liftCompare comp x y
 
 instance (Read1 f) => Read1 (Backwards f) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith rp rl) "Backwards" Backwards
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp rl) "Backwards" Backwards
 
 instance (Show1 f) => Show1 (Backwards f) where
-    showsPrecWith sp sl d (Backwards x) =
-        showsUnaryWith (showsPrecWith sp sl) "Backwards" d x
+    liftShowsPrec sp sl d (Backwards x) =
+        showsUnaryWith (liftShowsPrec sp sl) "Backwards" d x
 
 instance (Eq1 f, Eq a) => Eq (Backwards f a) where (==) = eq1
 instance (Ord1 f, Ord a) => Ord (Backwards f a) where compare = compare1
index f6e08bc..dc654c8 100644 (file)
@@ -42,26 +42,26 @@ import Data.Traversable (Traversable(traverse))
 data Lift f a = Pure a | Other (f a)
 
 instance (Eq1 f) => Eq1 (Lift f) where
-    eqWith eq (Pure x1) (Pure x2) = eq x1 x2
-    eqWith _ (Pure _) (Other _) = False
-    eqWith _ (Other _) (Pure _) = False
-    eqWith eq (Other y1) (Other y2) = eqWith eq y1 y2
+    liftEq eq (Pure x1) (Pure x2) = eq x1 x2
+    liftEq _ (Pure _) (Other _) = False
+    liftEq _ (Other _) (Pure _) = False
+    liftEq eq (Other y1) (Other y2) = liftEq eq y1 y2
 
 instance (Ord1 f) => Ord1 (Lift f) where
-    compareWith comp (Pure x1) (Pure x2) = comp x1 x2
-    compareWith _ (Pure _) (Other _) = LT
-    compareWith _ (Other _) (Pure _) = GT
-    compareWith comp (Other y1) (Other y2) = compareWith comp y1 y2
+    liftCompare comp (Pure x1) (Pure x2) = comp x1 x2
+    liftCompare _ (Pure _) (Other _) = LT
+    liftCompare _ (Other _) (Pure _) = GT
+    liftCompare comp (Other y1) (Other y2) = liftCompare comp y1 y2
 
 instance (Read1 f) => Read1 (Lift f) where
-    readsPrecWith rp rl = readsData $
+    liftReadsPrec rp rl = readsData $
         readsUnaryWith rp "Pure" Pure `mappend`
-        readsUnaryWith (readsPrecWith rp rl) "Other" Other
+        readsUnaryWith (liftReadsPrec rp rl) "Other" Other
 
 instance (Show1 f) => Show1 (Lift f) where
-    showsPrecWith sp _ d (Pure x) = showsUnaryWith sp "Pure" d x
-    showsPrecWith sp sl d (Other y) =
-        showsUnaryWith (showsPrecWith sp sl) "Other" d y
+    liftShowsPrec sp _ d (Pure x) = showsUnaryWith sp "Pure" d x
+    liftShowsPrec sp sl d (Other y) =
+        showsUnaryWith (liftShowsPrec sp sl) "Other" d y
 
 instance (Eq1 f, Eq a) => Eq (Lift f a) where (==) = eq1
 instance (Ord1 f, Ord a) => Ord (Lift f a) where compare = compare1
index 2d3b660..3f36a36 100644 (file)
@@ -166,18 +166,24 @@ instance ErrorList Char where
 newtype ErrorT e m a = ErrorT { runErrorT :: m (Either e a) }
 
 instance (Eq e, Eq1 m) => Eq1 (ErrorT e m) where
-    eqWith eq (ErrorT x) (ErrorT y) = eqWith (eqWith eq) x y
+    liftEq eq (ErrorT x) (ErrorT y) = liftEq (liftEq eq) x y
 
 instance (Ord e, Ord1 m) => Ord1 (ErrorT e m) where
-    compareWith comp (ErrorT x) (ErrorT y) = compareWith (compareWith comp) x y
+    liftCompare comp (ErrorT x) (ErrorT y) = liftCompare (liftCompare comp) x y
 
 instance (Read e, Read1 m) => Read1 (ErrorT e m) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith' (readsPrecWith rp rl)) "ErrorT" ErrorT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "ErrorT" ErrorT
+      where
+        rp' = liftReadsPrec rp rl
+        rl' = liftReadList rp rl
 
 instance (Show e, Show1 m) => Show1 (ErrorT e m) where
-    showsPrecWith sp sl d (ErrorT m) =
-        showsUnaryWith (showsPrecWith' (showsPrecWith sp sl)) "ErrorT" d m
+    liftShowsPrec sp sl d (ErrorT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "ErrorT" d m
+      where
+        sp' = liftShowsPrec sp sl
+        sl' = liftShowList sp sl
 
 instance (Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) where (==) = eq1
 instance (Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) where compare = compare1
index 0020f91..1e71188 100644 (file)
@@ -112,19 +112,25 @@ withExcept = withExceptT
 newtype ExceptT e m a = ExceptT (m (Either e a))
 
 instance (Eq e, Eq1 m) => Eq1 (ExceptT e m) where
-    eqWith eq (ExceptT x) (ExceptT y) = eqWith (eqWith eq) x y
+    liftEq eq (ExceptT x) (ExceptT y) = liftEq (liftEq eq) x y
 
 instance (Ord e, Ord1 m) => Ord1 (ExceptT e m) where
-    compareWith comp (ExceptT x) (ExceptT y) =
-        compareWith (compareWith comp) x y
+    liftCompare comp (ExceptT x) (ExceptT y) =
+        liftCompare (liftCompare comp) x y
 
 instance (Read e, Read1 m) => Read1 (ExceptT e m) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith' (readsPrecWith rp rl)) "ExceptT" ExceptT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "ExceptT" ExceptT
+      where
+        rp' = liftReadsPrec rp rl
+        rl' = liftReadList rp rl
 
 instance (Show e, Show1 m) => Show1 (ExceptT e m) where
-    showsPrecWith sp sl d (ExceptT m) =
-        showsUnaryWith (showsPrecWith' (showsPrecWith sp sl)) "ExceptT" d m
+    liftShowsPrec sp sl d (ExceptT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "ExceptT" d m
+      where
+        sp' = liftShowsPrec sp sl
+        sl' = liftShowList sp sl
 
 instance (Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) where (==) = eq1
 instance (Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) where compare = compare1
index 2d5de80..9ea1878 100644 (file)
@@ -53,18 +53,18 @@ import Data.Traversable (Traversable(traverse))
 newtype IdentityT f a = IdentityT { runIdentityT :: f a }
 
 instance (Eq1 f) => Eq1 (IdentityT f) where
-    eqWith eq (IdentityT x) (IdentityT y) = eqWith eq x y
+    liftEq eq (IdentityT x) (IdentityT y) = liftEq eq x y
 
 instance (Ord1 f) => Ord1 (IdentityT f) where
-    compareWith comp (IdentityT x) (IdentityT y) = compareWith comp x y
+    liftCompare comp (IdentityT x) (IdentityT y) = liftCompare comp x y
 
 instance (Read1 f) => Read1 (IdentityT f) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith rp rl) "IdentityT" IdentityT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp rl) "IdentityT" IdentityT
 
 instance (Show1 f) => Show1 (IdentityT f) where
-    showsPrecWith sp sl d (IdentityT m) =
-        showsUnaryWith (showsPrecWith sp sl) "IdentityT" d m
+    liftShowsPrec sp sl d (IdentityT m) =
+        showsUnaryWith (liftShowsPrec sp sl) "IdentityT" d m
 
 instance (Eq1 f, Eq a) => Eq (IdentityT f a) where (==) = eq1
 instance (Ord1 f, Ord a) => Ord (IdentityT f a) where compare = compare1
index d33f32b..3730a25 100644 (file)
@@ -51,18 +51,24 @@ import Data.Traversable (Traversable(traverse))
 newtype ListT m a = ListT { runListT :: m [a] }
 
 instance (Eq1 m) => Eq1 (ListT m) where
-    eqWith eq (ListT x) (ListT y) = eqWith (eqWith eq) x y
+    liftEq eq (ListT x) (ListT y) = liftEq (liftEq eq) x y
 
 instance (Ord1 m) => Ord1 (ListT m) where
-    compareWith comp (ListT x) (ListT y) = compareWith (compareWith comp) x y
+    liftCompare comp (ListT x) (ListT y) = liftCompare (liftCompare comp) x y
 
 instance (Read1 m) => Read1 (ListT m) where
-    readsPrecWith _ rl = readsData $
-        readsUnaryWith (readsPrecWith' (const rl)) "ListT" ListT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "ListT" ListT
+      where
+        rp' = liftReadsPrec rp rl
+        rl' = liftReadList rp rl
 
 instance (Show1 m) => Show1 (ListT m) where
-    showsPrecWith _ sl d (ListT m) =
-        showsUnaryWith (showsPrecWith' (const sl)) "ListT" d m
+    liftShowsPrec sp sl d (ListT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "ListT" d m
+      where
+        sp' = liftShowsPrec sp sl
+        sl' = liftShowList sp sl
 
 instance (Eq1 m, Eq a) => Eq (ListT m a) where (==) = eq1
 instance (Ord1 m, Ord a) => Ord (ListT m a) where compare = compare1
index 0a81914..9931979 100644 (file)
@@ -70,18 +70,24 @@ import Data.Traversable (Traversable(traverse))
 newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }
 
 instance (Eq1 m) => Eq1 (MaybeT m) where
-    eqWith eq (MaybeT x) (MaybeT y) = eqWith (eqWith eq) x y
+    liftEq eq (MaybeT x) (MaybeT y) = liftEq (liftEq eq) x y
 
 instance (Ord1 m) => Ord1 (MaybeT m) where
-    compareWith comp (MaybeT x) (MaybeT y) = compareWith (compareWith comp) x y
+    liftCompare comp (MaybeT x) (MaybeT y) = liftCompare (liftCompare comp) x y
 
 instance (Read1 m) => Read1 (MaybeT m) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith' (readsPrecWith rp rl)) "MaybeT" MaybeT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "MaybeT" MaybeT
+      where
+        rp' = liftReadsPrec rp rl
+        rl' = liftReadList rp rl
 
 instance (Show1 m) => Show1 (MaybeT m) where
-    showsPrecWith sp sl d (MaybeT m) =
-        showsUnaryWith (showsPrecWith' (showsPrecWith sp sl)) "MaybeT" d m
+    liftShowsPrec sp sl d (MaybeT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "MaybeT" d m
+      where
+        sp' = liftShowsPrec sp sl
+        sl' = liftShowList sp sl
 
 instance (Eq1 m, Eq a) => Eq (MaybeT m a) where (==) = eq1
 instance (Ord1 m, Ord a) => Ord (MaybeT m a) where compare = compare1
index 659c288..fd648e8 100644 (file)
@@ -110,20 +110,25 @@ mapWriter f = mapWriterT (Identity . f . runIdentity)
 newtype WriterT w m a = WriterT { runWriterT :: m (a, w) }
 
 instance (Eq w, Eq1 m) => Eq1 (WriterT w m) where
-    eqWith eq (WriterT m1) (WriterT m2) = eqWith (eqWith2 eq (==)) m1 m2
+    liftEq eq (WriterT m1) (WriterT m2) = liftEq (liftEq2 eq (==)) m1 m2
 
 instance (Ord w, Ord1 m) => Ord1 (WriterT w m) where
-    compareWith comp (WriterT m1) (WriterT m2) =
-        compareWith (compareWith2 comp compare) m1 m2
+    liftCompare comp (WriterT m1) (WriterT m2) =
+        liftCompare (liftCompare2 comp compare) m1 m2
 
 instance (Read w, Read1 m) => Read1 (WriterT w m) where
-    readsPrecWith rp _ = readsData $
-        readsUnaryWith (readsPrecWith' (readsPrecWith2 rp readsPrec))
-            "WriterT" WriterT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "WriterT" WriterT
+      where
+        rp' = liftReadsPrec2 rp rl readsPrec readList
+        rl' = liftReadList2 rp rl readsPrec readList
 
 instance (Show w, Show1 m) => Show1 (WriterT w m) where
-    showsPrecWith sp _ d (WriterT m) =
-        showsUnaryWith (showsPrecWith' (showsPrecWith2 sp showsPrec)) "WriterT" d m
+    liftShowsPrec sp sl d (WriterT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "WriterT" d m
+      where
+        sp' = liftShowsPrec2 sp sl showsPrec showList
+        sl' = liftShowList2 sp sl showsPrec showList
 
 instance (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) where (==) = eq1
 instance (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) where compare = compare1
index e0c1f93..4055f87 100644 (file)
@@ -113,20 +113,25 @@ mapWriter f = mapWriterT (Identity . f . runIdentity)
 newtype WriterT w m a = WriterT { runWriterT :: m (a, w) }
 
 instance (Eq w, Eq1 m) => Eq1 (WriterT w m) where
-    eqWith eq (WriterT m1) (WriterT m2) = eqWith (eqWith2 eq (==)) m1 m2
+    liftEq eq (WriterT m1) (WriterT m2) = liftEq (liftEq2 eq (==)) m1 m2
 
 instance (Ord w, Ord1 m) => Ord1 (WriterT w m) where
-    compareWith comp (WriterT m1) (WriterT m2) =
-        compareWith (compareWith2 comp compare) m1 m2
+    liftCompare comp (WriterT m1) (WriterT m2) =
+        liftCompare (liftCompare2 comp compare) m1 m2
 
 instance (Read w, Read1 m) => Read1 (WriterT w m) where
-    readsPrecWith rp _ = readsData $
-        readsUnaryWith (readsPrecWith' (readsPrecWith2 rp readsPrec))
-            "WriterT" WriterT
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "WriterT" WriterT
+      where
+        rp' = liftReadsPrec2 rp rl readsPrec readList
+        rl' = liftReadList2 rp rl readsPrec readList
 
 instance (Show w, Show1 m) => Show1 (WriterT w m) where
-    showsPrecWith sp _ d (WriterT m) =
-        showsUnaryWith (showsPrecWith' (showsPrecWith2 sp showsPrec)) "WriterT" d m
+    liftShowsPrec sp sl d (WriterT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "WriterT" d m
+      where
+        sp' = liftShowsPrec2 sp sl showsPrec showList
+        sl' = liftShowList2 sp sl showsPrec showList
 
 instance (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) where (==) = eq1
 instance (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) where compare = compare1
index 4319165..211a0db 100644 (file)
@@ -51,12 +51,9 @@ module Data.Functor.Classes (
     Show2(..), showsPrec2,
     -- * Helper functions
     -- $example
-    -- readsPrecWith',
-    readsPrecWith',
     readsData,
     readsUnaryWith,
     readsBinaryWith,
-    showsPrecWith',
     showsUnaryWith,
     showsBinaryWith,
     -- ** Obsolete helpers
@@ -81,11 +78,11 @@ class Eq1 f where
     -- but the more general type ensures that the implementation uses
     -- it to compare elements of the first container with elements of
     -- the second.
-    eqWith :: (a -> b -> Bool) -> f a -> f b -> Bool
+    liftEq :: (a -> b -> Bool) -> f a -> f b -> Bool
 
 -- | Lift the standard @('==')@ function through the type constructor.
 eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool
-eq1 = eqWith (==)
+eq1 = liftEq (==)
 
 -- | Lifting of the 'Ord' class to unary type constructors.
 class (Eq1 f) => Ord1 f where
@@ -95,32 +92,60 @@ class (Eq1 f) => Ord1 f where
     -- but the more general type ensures that the implementation uses
     -- it to compare elements of the first container with elements of
     -- the second.
-    compareWith :: (a -> b -> Ordering) -> f a -> f b -> Ordering
+    liftCompare :: (a -> b -> Ordering) -> f a -> f b -> Ordering
 
 -- | Lift the standard 'compare' function through the type constructor.
 compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering
-compare1 = compareWith compare
+compare1 = liftCompare compare
 
 -- | Lifting of the 'Read' class to unary type constructors.
 class Read1 f where
-    -- | Lift 'readsPrec' and 'readList' functions through the type constructor.
-    readsPrecWith :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
+    -- | 'readsPrec' function for an application of the type constructor
+    -- based on 'readsPrec' and 'readList' functions for the argument type.
+    liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
+
+    -- | 'readList' function for an application of the type constructor
+    -- based on 'readsPrec' and 'readList' functions for the argument type.
+    -- The default implementation using standard list syntax is correct
+    -- for most types.
+    liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
+    liftReadList rp rl = readListWith (liftReadsPrec rp rl 0)
+
+-- | Read a list (using square brackets and commas), given a function
+-- for reading elements.
+readListWith :: ReadS a -> ReadS [a]
+readListWith rp =
+    readParen False (\r -> [pr | ("[",s) <- lex r, pr <- readl s])
+  where
+    readl s = [([],t) | ("]",t) <- lex s] ++
+        [(x:xs,u) | (x,t) <- rp s, (xs,u) <- readl' t]
+    readl' s = [([],t) | ("]",t) <- lex s] ++
+        [(x:xs,v) | (",",t) <- lex s, (x,u) <- rp t, (xs,v) <- readl' u]
 
 -- | Lift the standard 'readsPrec' and 'readList' functions through the
 -- type constructor.
 readsPrec1 :: (Read1 f, Read a) => Int -> ReadS (f a)
-readsPrec1 = readsPrecWith readsPrec readList
+readsPrec1 = liftReadsPrec readsPrec readList
 
 -- | Lifting of the 'Show' class to unary type constructors.
 class Show1 f where
-    -- | Lift 'showsPrec' and 'showList' functions through the type constructor.
-    showsPrecWith :: (Int -> a -> ShowS) -> ([a] -> ShowS) ->
+    -- | 'showsPrec' function for an application of the type constructor
+    -- based on 'showsPrec' and 'showList' functions for the argument type.
+    liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) ->
         Int -> f a -> ShowS
 
+    -- | 'showList' function for an application of the type constructor
+    -- based on 'showsPrec' and 'showList' functions for the argument type.
+    -- The default implementation using standard list syntax is correct
+    -- for most types.
+    liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) ->
+        [f a] -> ShowS
+    liftShowList sp sl = showListWith (liftShowsPrec sp sl 0)
+
 -- | Lift the standard 'showsPrec' and 'showList' functions through the
 -- type constructor.
 showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS
-showsPrec1 = showsPrecWith showsPrec showList
+showsPrec1 = liftShowsPrec showsPrec showList
 
 -- | Lifting of the 'Eq' class to binary type constructors.
 class Eq2 f where
@@ -130,11 +155,11 @@ class Eq2 f where
     -- but the more general type ensures that the implementation uses
     -- them to compare elements of the first container with elements of
     -- the second.
-    eqWith2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
+    liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
 
 -- | Lift the standard @('==')@ function through the type constructor.
 eq2 :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool
-eq2 = eqWith2 (==) (==)
+eq2 = liftEq2 (==) (==)
 
 -- | Lifting of the 'Ord' class to binary type constructors.
 class (Eq2 f) => Ord2 f where
@@ -144,84 +169,104 @@ class (Eq2 f) => Ord2 f where
     -- but the more general type ensures that the implementation uses
     -- them to compare elements of the first container with elements of
     -- the second.
-    compareWith2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) ->
+    liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) ->
         f a c -> f b d -> Ordering
 
 -- | Lift the standard 'compare' function through the type constructor.
 compare2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Ordering
-compare2 = compareWith2 compare compare
+compare2 = liftCompare2 compare compare
 
 -- | Lifting of the 'Read' class to binary type constructors.
 class Read2 f where
-    -- | Lift 'readsPrec' functions through the type constructor.
-    readsPrecWith2 :: (Int -> ReadS a) -> (Int -> ReadS b) ->
-        Int -> ReadS (f a b)
+    -- | 'readsPrec' function for an application of the type constructor
+    -- based on 'readsPrec' and 'readList' functions for the argument types.
+    liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] ->
+        (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (f a b)
+
+    -- | 'readList' function for an application of the type constructor
+    -- based on 'readsPrec' and 'readList' functions for the argument types.
+    -- The default implementation using standard list syntax is correct
+    -- for most types.
+    liftReadList2 :: (Int -> ReadS a) -> ReadS [a] ->
+        (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
+    liftReadList2 rp1 rl1 rp2 rl2 =
+        readListWith (liftReadsPrec2 rp1 rl1 rp2 rl2 0)
 
 -- | Lift the standard 'readsPrec' function through the type constructor.
 readsPrec2 :: (Read2 f, Read a, Read b) => Int -> ReadS (f a b)
-readsPrec2 = readsPrecWith2 readsPrec readsPrec
+readsPrec2 = liftReadsPrec2 readsPrec readList readsPrec readList
 
 -- | Lifting of the 'Show' class to binary type constructors.
 class Show2 f where
-    -- | Lift 'showsPrec' functions through the type constructor.
-    showsPrecWith2 :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) ->
-        Int -> f a b -> ShowS
+    -- | 'showsPrec' function for an application of the type constructor
+    -- based on 'showsPrec' and 'showList' functions for the argument types.
+    liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) ->
+        (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> f a b -> ShowS
+
+    -- | 'showList' function for an application of the type constructor
+    -- based on 'showsPrec' and 'showList' functions for the argument types.
+    -- The default implementation using standard list syntax is correct
+    -- for most types.
+    liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) ->
+        (Int -> b -> ShowS) -> ([b] -> ShowS) -> [f a b] -> ShowS
+    liftShowList2 sp1 sl1 sp2 sl2 =
+        showListWith (liftShowsPrec2 sp1 sl1 sp2 sl2 0)
 
 -- | Lift the standard 'showsPrec' function through the type constructor.
 showsPrec2 :: (Show2 f, Show a, Show b) => Int -> f a b -> ShowS
-showsPrec2 = showsPrecWith2 showsPrec showsPrec
+showsPrec2 = liftShowsPrec2 showsPrec showList showsPrec showList
 
 -- Instances for Prelude type constructors
 
 instance Eq1 Maybe where
-    eqWith _ Nothing Nothing = True
-    eqWith _ Nothing (Just _) = False
-    eqWith _ (Just _) Nothing = False
-    eqWith eq (Just x) (Just y) = eq x y
+    liftEq _ Nothing Nothing = True
+    liftEq _ Nothing (Just _) = False
+    liftEq _ (Just _) Nothing = False
+    liftEq eq (Just x) (Just y) = eq x y
 
 instance Ord1 Maybe where
-    compareWith _ Nothing Nothing = EQ
-    compareWith _ Nothing (Just _) = LT
-    compareWith _ (Just _) Nothing = GT
-    compareWith comp (Just x) (Just y) = comp x y
+    liftCompare _ Nothing Nothing = EQ
+    liftCompare _ Nothing (Just _) = LT
+    liftCompare _ (Just _) Nothing = GT
+    liftCompare comp (Just x) (Just y) = comp x y
 
 instance Read1 Maybe where
-    readsPrecWith rp _ d =
+    liftReadsPrec rp _ d =
          readParen False (\ r -> [(Nothing,s) | ("Nothing",s) <- lex r])
          `mappend`
          readsData (readsUnaryWith rp "Just" Just) d
 
 instance Show1 Maybe where
-    showsPrecWith _ _ _ Nothing = showString "Nothing"
-    showsPrecWith sp _ d (Just x) = showsUnaryWith sp "Just" d x
+    liftShowsPrec _ _ _ Nothing = showString "Nothing"
+    liftShowsPrec sp _ d (Just x) = showsUnaryWith sp "Just" d x
 
 instance Eq1 [] where
-    eqWith _ [] [] = True
-    eqWith _ [] (_:_) = False
-    eqWith _ (_:_) [] = False
-    eqWith eq (x:xs) (y:ys) = eq x y && eqWith eq xs ys
+    liftEq _ [] [] = True
+    liftEq _ [] (_:_) = False
+    liftEq _ (_:_) [] = False
+    liftEq eq (x:xs) (y:ys) = eq x y && liftEq eq xs ys
 
 instance Ord1 [] where
-    compareWith _ [] [] = EQ
-    compareWith _ [] (_:_) = LT
-    compareWith _ (_:_) [] = GT
-    compareWith comp (x:xs) (y:ys) = comp x y `mappend` compareWith comp xs ys
+    liftCompare _ [] [] = EQ
+    liftCompare _ [] (_:_) = LT
+    liftCompare _ (_:_) [] = GT
+    liftCompare comp (x:xs) (y:ys) = comp x y `mappend` liftCompare comp xs ys
 
 instance Read1 [] where
-    readsPrecWith _ rl _ = rl
+    liftReadsPrec _ rl _ = rl
 
 instance Show1 [] where
-    showsPrecWith _ sl _ = sl
+    liftShowsPrec _ sl _ = sl
 
 instance Eq2 (,) where
-    eqWith2 e1 e2 (x1, y1) (x2, y2) = e1 x1 x2 && e2 y1 y2
+    liftEq2 e1 e2 (x1, y1) (x2, y2) = e1 x1 x2 && e2 y1 y2
 
 instance Ord2 (,) where
-    compareWith2 comp1 comp2 (x1, y1) (x2, y2) =
+    liftCompare2 comp1 comp2 (x1, y1) (x2, y2) =
         comp1 x1 x2 `mappend` comp2 y1 y2
 
 instance Read2 (,) where
-    readsPrecWith2 rp1 rp2 _ = readParen False $ \ r ->
+    liftReadsPrec2 rp1 _ rp2 _ _ = readParen False $ \ r ->
         [((x,y), w) | ("(",s) <- lex r,
                       (x,t)   <- rp1 0 s,
                       (",",u) <- lex t,
@@ -229,109 +274,93 @@ instance Read2 (,) where
                       (")",w) <- lex v]
 
 instance Show2 (,) where
-    showsPrecWith2 sp1 sp2 _ (x, y) =
+    liftShowsPrec2 sp1 _ sp2 _ _ (x, y) =
         showChar '(' . sp1 0 x . showChar ',' . sp2 0 y . showChar ')'
 
 instance (Eq a) => Eq1 ((,) a) where
-    eqWith = eqWith2 (==)
+    liftEq = liftEq2 (==)
 
 instance (Ord a) => Ord1 ((,) a) where
-    compareWith = compareWith2 compare
+    liftCompare = liftCompare2 compare
 
 instance (Read a) => Read1 ((,) a) where
-    readsPrecWith rp _ = readsPrecWith2 readsPrec rp
+    liftReadsPrec = liftReadsPrec2 readsPrec readList
 
 instance (Show a) => Show1 ((,) a) where
-    showsPrecWith sp _ = showsPrecWith2 showsPrec sp
+    liftShowsPrec = liftShowsPrec2 showsPrec showList
 
 instance Eq2 Either where
-    eqWith2 e1 _ (Left x) (Left y) = e1 x y
-    eqWith2 _ _ (Left _) (Right _) = False
-    eqWith2 _ _ (Right _) (Left _) = False
-    eqWith2 _ e2 (Right x) (Right y) = e2 x y
+    liftEq2 e1 _ (Left x) (Left y) = e1 x y
+    liftEq2 _ _ (Left _) (Right _) = False
+    liftEq2 _ _ (Right _) (Left _) = False
+    liftEq2 _ e2 (Right x) (Right y) = e2 x y
 
 instance Ord2 Either where
-    compareWith2 comp1 _ (Left x) (Left y) = comp1 x y
-    compareWith2 _ _ (Left _) (Right _) = LT
-    compareWith2 _ _ (Right _) (Left _) = GT
-    compareWith2 _ comp2 (Right x) (Right y) = comp2 x y
+    liftCompare2 comp1 _ (Left x) (Left y) = comp1 x y
+    liftCompare2 _ _ (Left _) (Right _) = LT
+    liftCompare2 _ _ (Right _) (Left _) = GT
+    liftCompare2 _ comp2 (Right x) (Right y) = comp2 x y
 
 instance Read2 Either where
-    readsPrecWith2 rp1 rp2 = readsData $
+    liftReadsPrec2 rp1 _ rp2 _ = readsData $
          readsUnaryWith rp1 "Left" Left `mappend`
          readsUnaryWith rp2 "Right" Right
 
 instance Show2 Either where
-    showsPrecWith2 sp1 _ d (Left x) = showsUnaryWith sp1 "Left" d x
-    showsPrecWith2 _ sp2 d (Right x) = showsUnaryWith sp2 "Right" d x
+    liftShowsPrec2 sp1 _ _ _ d (Left x) = showsUnaryWith sp1 "Left" d x
+    liftShowsPrec2 _ _ sp2 _ d (Right x) = showsUnaryWith sp2 "Right" d x
 
 instance (Eq a) => Eq1 (Either a) where
-    eqWith = eqWith2 (==)
+    liftEq = liftEq2 (==)
 
 instance (Ord a) => Ord1 (Either a) where
-    compareWith = compareWith2 compare
+    liftCompare = liftCompare2 compare
 
 instance (Read a) => Read1 (Either a) where
-    readsPrecWith rp _ = readsPrecWith2 readsPrec rp
+    liftReadsPrec = liftReadsPrec2 readsPrec readList
 
 instance (Show a) => Show1 (Either a) where
-    showsPrecWith sp _ = showsPrecWith2 showsPrec sp
+    liftShowsPrec = liftShowsPrec2 showsPrec showList
 
 -- Instances for other functors defined in the base package
 
 instance Eq1 Identity where
-    eqWith eq (Identity x) (Identity y) = eq x y
+    liftEq eq (Identity x) (Identity y) = eq x y
 
 instance Ord1 Identity where
-    compareWith comp (Identity x) (Identity y) = comp x y
+    liftCompare comp (Identity x) (Identity y) = comp x y
 
 instance Read1 Identity where
-    readsPrecWith rp _ = readsData $
+    liftReadsPrec rp _ = readsData $
          readsUnaryWith rp "Identity" Identity
 
 instance Show1 Identity where
-    showsPrecWith sp _ d (Identity x) = showsUnaryWith sp "Identity" d x
+    liftShowsPrec sp _ d (Identity x) = showsUnaryWith sp "Identity" d x
 
 instance Eq2 Const where
-    eqWith2 eq _ (Const x) (Const y) = eq x y
+    liftEq2 eq _ (Const x) (Const y) = eq x y
 
 instance Ord2 Const where
-    compareWith2 comp _ (Const x) (Const y) = comp x y
+    liftCompare2 comp _ (Const x) (Const y) = comp x y
 
 instance Read2 Const where
-    readsPrecWith2 rp _ = readsData $
+    liftReadsPrec2 rp _ _ _ = readsData $
          readsUnaryWith rp "Const" Const
 
 instance Show2 Const where
-    showsPrecWith2 sp _ d (Const x) = showsUnaryWith sp "Const" d x
+    liftShowsPrec2 sp _ _ _ d (Const x) = showsUnaryWith sp "Const" d x
 
 instance (Eq a) => Eq1 (Const a) where
-    eqWith = eqWith2 (==)
+    liftEq = liftEq2 (==)
 instance (Ord a) => Ord1 (Const a) where
-    compareWith = compareWith2 compare
+    liftCompare = liftCompare2 compare
 instance (Read a) => Read1 (Const a) where
-    readsPrecWith rp _ = readsPrecWith2 readsPrec rp
+    liftReadsPrec = liftReadsPrec2 readsPrec readList
 instance (Show a) => Show1 (Const a) where
-    showsPrecWith sp _ = showsPrecWith2 showsPrec sp
+    liftShowsPrec = liftShowsPrec2 showsPrec showList
 
 -- Building blocks
 
--- | Simplified version of 'readsPrecWith' for use when the argument type
--- is assumed not to have a special version of 'readList'.
-readsPrecWith' :: Read1 f => (Int -> ReadS (g a)) -> Int -> ReadS (f (g a))
-readsPrecWith' rp = readsPrecWith rp (readListWith (rp 0))
-
--- | Read a list (using square brackets and commas), given a function
--- for reading elements.
-readListWith :: ReadS a -> ReadS [a]
-readListWith rp =
-    readParen False (\r -> [pr | ("[",s) <- lex r, pr <- readl s])
-  where
-    readl s = [([],t) | ("]",t) <- lex s] ++
-        [(x:xs,u) | (x,t) <- rp s, (xs,u) <- readl' t]
-    readl' s = [([],t) | ("]",t) <- lex s] ++
-        [(x:xs,v) | (",",t) <- lex s, (x,u) <- rp t, (xs,v) <- readl' u]
-
 -- | @'readsData' p d@ is a parser for datatypes where each alternative
 -- begins with a data constructor.  It parses the constructor and
 -- passes it to @p@.  Parsers for various constructors can be constructed
@@ -355,11 +384,6 @@ readsBinaryWith :: (Int -> ReadS a) -> (Int -> ReadS b) ->
 readsBinaryWith rp1 rp2 name cons kw s =
     [(cons x y,u) | kw == name, (x,t) <- rp1 11 s, (y,u) <- rp2 11 t]
 
--- | Simplified version of 'showsPrecWith' for use when the argument type
--- is assumed not to have a special version of 'showList'.
-showsPrecWith' :: Show1 f => (Int -> g a -> ShowS) -> Int -> f (g a) -> ShowS
-showsPrecWith' sp = showsPrecWith sp (showListWith (sp 0))
-
 -- | @'showsUnaryWith' sp n d x@ produces the string representation of a
 -- unary data constructor with name @n@ and argument @x@, in precedence
 -- context @d@.
@@ -379,21 +403,21 @@ showsBinaryWith sp1 sp2 name d x y = showParen (d > 10) $
 
 -- | @'readsUnary' n c n'@ matches the name of a unary data constructor
 -- and then parses its argument using 'readsPrec'.
-{-# DEPRECATED readsUnary "Use readsUnaryWith to define readsPrecWith" #-}
+{-# DEPRECATED readsUnary "Use readsUnaryWith to define liftReadsPrec" #-}
 readsUnary :: (Read a) => String -> (a -> t) -> String -> ReadS t
 readsUnary name cons kw s =
     [(cons x,t) | kw == name, (x,t) <- readsPrec 11 s]
 
 -- | @'readsUnary1' n c n'@ matches the name of a unary data constructor
 -- and then parses its argument using 'readsPrec1'.
-{-# DEPRECATED readsUnary1 "Use readsUnaryWith to define readsPrecWith" #-}
+{-# DEPRECATED readsUnary1 "Use readsUnaryWith to define liftReadsPrec" #-}
 readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t
 readsUnary1 name cons kw s =
     [(cons x,t) | kw == name, (x,t) <- readsPrec1 11 s]
 
 -- | @'readsBinary1' n c n'@ matches the name of a binary data constructor
 -- and then parses its arguments using 'readsPrec1'.
-{-# DEPRECATED readsBinary1 "Use readsBinaryWith to define readsPrecWith" #-}
+{-# DEPRECATED readsBinary1 "Use readsBinaryWith to define liftReadsPrec" #-}
 readsBinary1 :: (Read1 f, Read1 g, Read a) =>
     String -> (f a -> g a -> t) -> String -> ReadS t
 readsBinary1 name cons kw s =
@@ -402,14 +426,14 @@ readsBinary1 name cons kw s =
 
 -- | @'showsUnary' n d x@ produces the string representation of a unary data
 -- constructor with name @n@ and argument @x@, in precedence context @d@.
-{-# DEPRECATED showsUnary "Use showsUnaryWith to define showsPrecWith" #-}
+{-# DEPRECATED showsUnary "Use showsUnaryWith to define liftShowsPrec" #-}
 showsUnary :: (Show a) => String -> Int -> a -> ShowS
 showsUnary name d x = showParen (d > 10) $
     showString name . showChar ' ' . showsPrec 11 x
 
 -- | @'showsUnary1' n d x@ produces the string representation of a unary data
 -- constructor with name @n@ and argument @x@, in precedence context @d@.
-{-# DEPRECATED showsUnary1 "Use showsUnaryWith to define showsPrecWith" #-}
+{-# DEPRECATED showsUnary1 "Use showsUnaryWith to define liftShowsPrec" #-}
 showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS
 showsUnary1 name d x = showParen (d > 10) $
     showString name . showChar ' ' . showsPrec1 11 x
@@ -417,7 +441,7 @@ showsUnary1 name d x = showParen (d > 10) $
 -- | @'showsBinary1' n d x y@ produces the string representation of a binary
 -- data constructor with name @n@ and arguments @x@ and @y@, in precedence
 -- context @d@.
-{-# DEPRECATED showsBinary1 "Use showsBinaryWith to define showsPrecWith" #-}
+{-# DEPRECATED showsBinary1 "Use showsBinaryWith to define liftShowsPrec" #-}
 showsBinary1 :: (Show1 f, Show1 g, Show a) =>
     String -> Int -> f a -> g a -> ShowS
 showsBinary1 name d x y = showParen (d > 10) $
@@ -433,19 +457,19 @@ new algebraic types.  For example, given the definition
 a standard 'Read1' instance may be defined as
 
 > instance (Read1 f) => Read1 (T f) where
->     readsPrecWith rp rl = readsData $
+>     liftReadsPrec rp rl = readsData $
 >         readsUnaryWith rp "Zero" Zero `mappend`
->         readsUnaryWith (readsPrecWith rp rl) "One" One `mappend`
->         readsBinaryWith rp (readsPrecWith rp rl) "Two" Two
+>         readsUnaryWith (liftReadsPrec rp rl) "One" One `mappend`
+>         readsBinaryWith rp (liftReadsPrec rp rl) "Two" Two
 
 and the corresponding 'Show1' instance as
 
 > instance (Show1 f) => Show1 (T f) where
->     showsPrecWith sp _ d (Zero x) =
+>     liftShowsPrec sp _ d (Zero x) =
 >         showsUnaryWith sp "Zero" d x
->     showsPrecWith sp sl d (One x) =
->         showsUnaryWith (showsPrecWith sp sl) "One" d x
->     showsPrecWith sp sl d (Two x y) =
->         showsBinaryWith sp (showsPrecWith sp sl) "Two" d x y
+>     liftShowsPrec sp sl d (One x) =
+>         showsUnaryWith (liftShowsPrec sp sl) "One" d x
+>     liftShowsPrec sp sl d (Two x y) =
+>         showsBinaryWith sp (liftShowsPrec sp sl) "Two" d x y
 
 -}
index 64cb768..1b7785c 100644 (file)
@@ -41,19 +41,25 @@ newtype Compose f g a = Compose { getCompose :: f (g a) }
 -- Instances of lifted Prelude classes
 
 instance (Eq1 f, Eq1 g) => Eq1 (Compose f g) where
-    eqWith eq (Compose x) (Compose y) = eqWith (eqWith eq) x y
+    liftEq eq (Compose x) (Compose y) = liftEq (liftEq eq) x y
 
 instance (Ord1 f, Ord1 g) => Ord1 (Compose f g) where
-    compareWith comp (Compose x) (Compose y) =
-        compareWith (compareWith comp) x y
+    liftCompare comp (Compose x) (Compose y) =
+        liftCompare (liftCompare comp) x y
 
 instance (Read1 f, Read1 g) => Read1 (Compose f g) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith' (readsPrecWith rp rl)) "Compose" Compose
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "Compose" Compose
+      where
+        rp' = liftReadsPrec rp rl
+        rl' = liftReadList rp rl
 
 instance (Show1 f, Show1 g) => Show1 (Compose f g) where
-    showsPrecWith sp sl d (Compose x) =
-        showsUnaryWith (showsPrecWith' (showsPrecWith sp sl)) "Compose" d x
+    liftShowsPrec sp sl d (Compose x) =
+        showsUnaryWith (liftShowsPrec sp' sl') "Compose" d x
+      where
+        sp' = liftShowsPrec sp sl
+        sl' = liftShowList sp sl
 
 -- Instances of Prelude classes
 
index ae6a5ff..a34c1ca 100644 (file)
@@ -52,26 +52,26 @@ instance (Show a) => Show (Constant a b) where
 -- Instances of lifted Prelude classes
 
 instance Eq2 Constant where
-    eqWith2 eq _ (Constant x) (Constant y) = eq x y
+    liftEq2 eq _ (Constant x) (Constant y) = eq x y
 
 instance Ord2 Constant where
-    compareWith2 comp _ (Constant x) (Constant y) = comp x y 
+    liftCompare2 comp _ (Constant x) (Constant y) = comp x y
 
 instance Read2 Constant where
-    readsPrecWith2 rp _ = readsData $
+    liftReadsPrec2 rp _ _ _ = readsData $
          readsUnaryWith rp "Constant" Constant
 
 instance Show2 Constant where
-    showsPrecWith2 sp _ d (Constant x) = showsUnaryWith sp "Constant" d x
+    liftShowsPrec2 sp _ _ _ d (Constant x) = showsUnaryWith sp "Constant" d x
 
 instance (Eq a) => Eq1 (Constant a) where
-    eqWith = eqWith2 (==)
+    liftEq = liftEq2 (==)
 instance (Ord a) => Ord1 (Constant a) where
-    compareWith = compareWith2 compare
+    liftCompare = liftCompare2 compare
 instance (Read a) => Read1 (Constant a) where
-    readsPrecWith rp _ = readsPrecWith2 readsPrec rp
+    liftReadsPrec = liftReadsPrec2 readsPrec readList
 instance (Show a) => Show1 (Constant a) where
-    showsPrecWith sp _ = showsPrecWith2 showsPrec sp
+    liftShowsPrec = liftShowsPrec2 showsPrec showList
 
 instance Functor (Constant a) where
     fmap _ (Constant x) = Constant x
index aaf0a56..ea0898c 100644 (file)
@@ -40,19 +40,19 @@ import Data.Traversable (Traversable(traverse))
 data Product f g a = Pair (f a) (g a)
 
 instance (Eq1 f, Eq1 g) => Eq1 (Product f g) where
-    eqWith eq (Pair x1 y1) (Pair x2 y2) = eqWith eq x1 x2 && eqWith eq y1 y2
+    liftEq eq (Pair x1 y1) (Pair x2 y2) = liftEq eq x1 x2 && liftEq eq y1 y2
 
 instance (Ord1 f, Ord1 g) => Ord1 (Product f g) where
-    compareWith comp (Pair x1 y1) (Pair x2 y2) =
-        compareWith comp x1 x2 `mappend` compareWith comp y1 y2
+    liftCompare comp (Pair x1 y1) (Pair x2 y2) =
+        liftCompare comp x1 x2 `mappend` liftCompare comp y1 y2
 
 instance (Read1 f, Read1 g) => Read1 (Product f g) where
-    readsPrecWith rp rl = readsData $
-        readsBinaryWith (readsPrecWith rp rl) (readsPrecWith rp rl) "Pair" Pair
+    liftReadsPrec rp rl = readsData $
+        readsBinaryWith (liftReadsPrec rp rl) (liftReadsPrec rp rl) "Pair" Pair
 
 instance (Show1 f, Show1 g) => Show1 (Product f g) where
-    showsPrecWith sp sl d (Pair x y) =
-        showsBinaryWith (showsPrecWith sp sl) (showsPrecWith sp sl) "Pair" d x y
+    liftShowsPrec sp sl d (Pair x y) =
+        showsBinaryWith (liftShowsPrec sp sl) (liftShowsPrec sp sl) "Pair" d x y
 
 instance (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a)
     where (==) = eq1
index 7e09deb..baf70c8 100644 (file)
@@ -40,18 +40,18 @@ import Data.Monoid
 newtype Reverse f a = Reverse { getReverse :: f a }
 
 instance (Eq1 f) => Eq1 (Reverse f) where
-    eqWith eq (Reverse x) (Reverse y) = eqWith eq x y
+    liftEq eq (Reverse x) (Reverse y) = liftEq eq x y
 
 instance (Ord1 f) => Ord1 (Reverse f) where
-    compareWith comp (Reverse x) (Reverse y) = compareWith comp x y
+    liftCompare comp (Reverse x) (Reverse y) = liftCompare comp x y
 
 instance (Read1 f) => Read1 (Reverse f) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith rp rl) "Reverse" Reverse
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp rl) "Reverse" Reverse
 
 instance (Show1 f) => Show1 (Reverse f) where
-    showsPrecWith sp sl d (Reverse x) =
-        showsUnaryWith (showsPrecWith sp sl) "Reverse" d x
+    liftShowsPrec sp sl d (Reverse x) =
+        showsUnaryWith (liftShowsPrec sp sl) "Reverse" d x
 
 instance (Eq1 f, Eq a) => Eq (Reverse f a) where (==) = eq1
 instance (Ord1 f, Ord a) => Ord (Reverse f a) where compare = compare1
index 04940dd..e7c9f55 100644 (file)
@@ -35,27 +35,27 @@ import Data.Traversable (Traversable(traverse))
 data Sum f g a = InL (f a) | InR (g a)
 
 instance (Eq1 f, Eq1 g) => Eq1 (Sum f g) where
-    eqWith eq (InL x1) (InL x2) = eqWith eq x1 x2
-    eqWith _ (InL _) (InR _) = False
-    eqWith _ (InR _) (InL _) = False
-    eqWith eq (InR y1) (InR y2) = eqWith eq y1 y2
+    liftEq eq (InL x1) (InL x2) = liftEq eq x1 x2
+    liftEq _ (InL _) (InR _) = False
+    liftEq _ (InR _) (InL _) = False
+    liftEq eq (InR y1) (InR y2) = liftEq eq y1 y2
 
 instance (Ord1 f, Ord1 g) => Ord1 (Sum f g) where
-    compareWith comp (InL x1) (InL x2) = compareWith comp x1 x2
-    compareWith _ (InL _) (InR _) = LT
-    compareWith _ (InR _) (InL _) = GT
-    compareWith comp (InR y1) (InR y2) = compareWith comp y1 y2
+    liftCompare comp (InL x1) (InL x2) = liftCompare comp x1 x2
+    liftCompare _ (InL _) (InR _) = LT
+    liftCompare _ (InR _) (InL _) = GT
+    liftCompare comp (InR y1) (InR y2) = liftCompare comp y1 y2
 
 instance (Read1 f, Read1 g) => Read1 (Sum f g) where
-    readsPrecWith rp rl = readsData $
-        readsUnaryWith (readsPrecWith rp rl) "InL" InL `mappend`
-        readsUnaryWith (readsPrecWith rp rl) "InR" InR
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp rl) "InL" InL `mappend`
+        readsUnaryWith (liftReadsPrec rp rl) "InR" InR
 
 instance (Show1 f, Show1 g) => Show1 (Sum f g) where
-    showsPrecWith sp sl d (InL x) =
-        showsUnaryWith (showsPrecWith sp sl) "InL" d x
-    showsPrecWith sp sl d (InR y) =
-        showsUnaryWith (showsPrecWith sp sl) "InR" d y
+    liftShowsPrec sp sl d (InL x) =
+        showsUnaryWith (liftShowsPrec sp sl) "InL" d x
+    liftShowsPrec sp sl d (InR y) =
+        showsUnaryWith (liftShowsPrec sp sl) "InR" d y
 
 instance (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) where
     (==) = eq1