RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://hackage.haskell.org/package/base/docs/Data-Functor-Classes.html below:

Data.Functor.Classes

Description

Liftings of the Prelude classes Eq, Ord, Read and Show to unary and binary type constructors.

These classes are needed to express the constraints on arguments of transformers in portable Haskell. Thus for a new transformer T, one might write instances like

instance (Eq1 f) => Eq1 (T f) where ...
instance (Ord1 f) => Ord1 (T f) where ...
instance (Read1 f) => Read1 (T f) where ...
instance (Show1 f) => Show1 (T f) where ...

If these instances can be defined, defining instances of the base classes is mechanical:

instance (Eq1 f, Eq a) => Eq (T f a) where (==) = eq1
instance (Ord1 f, Ord a) => Ord (T f a) where compare = compare1
instance (Read1 f, Read a) => Read (T f a) where
  readPrec     = readPrec1
  readListPrec = readListPrecDefault
instance (Show1 f, Show a) => Show (T f a) where showsPrec = showsPrec1

Since: base-4.9.0.0

Synopsis

class (forall a. Eq a => Eq (f a)) => Eq1 (f :: Type -> Type) where
- liftEq :: (a -> b -> Bool) -> f a -> f b -> Bool
eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool
class (Eq1 f, forall a. Ord a => Ord (f a)) => Ord1 (f :: Type -> Type) where
- liftCompare :: (a -> b -> Ordering) -> f a -> f b -> Ordering
compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering
class (forall a. Read a => Read (f a)) => Read1 (f :: Type -> Type) where
- liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
- liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
- liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)
- liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
readsPrec1 :: (Read1 f, Read a) => Int -> ReadS (f a)
readPrec1 :: (Read1 f, Read a) => ReadPrec (f a)
liftReadListDefault :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
liftReadListPrecDefault :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
class (forall a. Show a => Show (f a)) => Show1 (f :: Type -> Type) where
- liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
- liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS
class (forall a. Eq a => Eq1 (f a)) => Eq2 (f :: Type -> Type -> Type) where
- liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
eq2 :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool
class (Eq2 f, forall a. Ord a => Ord1 (f a)) => Ord2 (f :: Type -> Type -> Type) where
- liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
compare2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Ordering
class (forall a. Read a => Read1 (f a)) => Read2 (f :: Type -> Type -> Type) where
- liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (f a b)
- liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
- liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (f a b)
- liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
readsPrec2 :: (Read2 f, Read a, Read b) => Int -> ReadS (f a b)
readPrec2 :: (Read2 f, Read a, Read b) => ReadPrec (f a b)
liftReadList2Default :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
liftReadListPrec2Default :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
class (forall a. Show a => Show1 (f a)) => Show2 (f :: Type -> Type -> Type) where
- liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> f a b -> ShowS
- liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [f a b] -> ShowS
showsPrec2 :: (Show2 f, Show a, Show b) => Int -> f a b -> ShowS
readsData :: (String -> ReadS a) -> Int -> ReadS a
readData :: ReadPrec a -> ReadPrec a
readsUnaryWith :: (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t
readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t
readsBinaryWith :: (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t
readBinaryWith :: ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t
showsUnaryWith :: (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
showsBinaryWith :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
readsUnary :: Read a => String -> (a -> t) -> String -> ReadS t
readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t
readsBinary1 :: (Read1 f, Read1 g, Read a) => String -> (f a -> g a -> t) -> String -> ReadS t
showsUnary :: Show a => String -> Int -> a -> ShowS
showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS
showsBinary1 :: (Show1 f, Show1 g, Show a) => String -> Int -> f a -> g a -> ShowS

Liftings of Prelude classes For unary constructors

class (forall a. Eq a => Eq (f a)) => Eq1 (f :: Type -> Type) where Source #

Lifting of the Eq class to unary type constructors.

Any instance should be subject to the following law that canonicity is preserved:

liftEq (==) = (==)

This class therefore represents the generalization of Eq by decomposing its main method into a canonical lifting on a canonical inner method, so that the lifting can be reused for other arguments than the canonical one.

Since: base-4.9.0.0

Minimal complete definition

Nothing

Methods

liftEq :: (a -> b -> Bool) -> f a -> f b -> Bool Source #

Lift an equality test through the type constructor.

The function will usually be applied to an equality function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.

Since: base-4.9.0.0

Instances Instances details Eq1 Complex Source #

>>> eq1 (1 :+ 2) (1 :+ 2)
True

>>> eq1 (1 :+ 2) (1 :+ 3)
False

Since: base-4.16.0.0

Instance details