transformers-0.4.2.0: Concrete functor and monad transformers

Copyright | (c) Ross Paterson 2013
License | BSD-style (see the file LICENSE)
Maintainer | ross@soi.city.ac.uk
Stability | experimental
Portability | portable
Safe Haskell | Safe
Language | Haskell98

Data.Functor.Classes

Contents

- Liftings of Prelude classes
- Helper functions

Description

Prelude classes, lifted to unary type constructors.

Synopsis

- class Eq1 f where
  - eq1 :: Eq a => f a -> f a -> Bool
- class Eq1 f => Ord1 f where
  - compare1 :: Ord a => f a -> f a -> Ordering
- class Read1 f where
  - readsPrec1 :: Read a => Int -> ReadS (f a)
- class Show1 f where
  - showsPrec1 :: Show a => Int -> f a -> ShowS
- readsData :: (String -> ReadS a) -> Int -> ReadS a
- 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

class Eq1 f where

Lifting of the `Eq` class to unary type constructors.

Methods

eq1 :: Eq a => f a -> f a -> Bool

Instances

Eq1 [] |
Eq1 Identity |
Eq1 Maybe |
Eq a => Eq1 (Either a) |
Eq a => Eq1 ((,) a) |
Eq a => Eq1 (Constant a) |
Eq1 f => Eq1 (Lift f) |
Eq1 f => Eq1 (IdentityT f) |
Eq1 m => Eq1 (ListT m) |
Eq1 m => Eq1 (MaybeT m) |
Eq1 f => Eq1 (Backwards f) |
Eq1 f => Eq1 (Reverse f) |
(Eq e, Eq1 m) => Eq1 (ExceptT e m) |
(Eq e, Eq1 m) => Eq1 (ErrorT e m) |
(Eq w, Eq1 m) => Eq1 (WriterT w m) |
(Eq w, Eq1 m) => Eq1 (WriterT w m) |
(Functor f, Eq1 f, Eq1 g) => Eq1 (Compose f g) |
(Eq1 f, Eq1 g) => Eq1 (Product f g) |
(Eq1 f, Eq1 g) => Eq1 (Sum f g) |

class Eq1 f => Ord1 f where

Lifting of the `Ord` class to unary type constructors.

Methods

compare1 :: Ord a => f a -> f a -> Ordering

Instances

Ord1 [] |
Ord1 Identity |
Ord1 Maybe |
Ord a => Ord1 (Either a) |
Ord a => Ord1 ((,) a) |
Ord a => Ord1 (Constant a) |
Ord1 f => Ord1 (Lift f) |
Ord1 f => Ord1 (IdentityT f) |
Ord1 m => Ord1 (ListT m) |
Ord1 m => Ord1 (MaybeT m) |
Ord1 f => Ord1 (Backwards f) |
Ord1 f => Ord1 (Reverse f) |
(Ord e, Ord1 m) => Ord1 (ExceptT e m) |
(Ord e, Ord1 m) => Ord1 (ErrorT e m) |
(Ord w, Ord1 m) => Ord1 (WriterT w m) |
(Ord w, Ord1 m) => Ord1 (WriterT w m) |
(Functor f, Ord1 f, Ord1 g) => Ord1 (Compose f g) |
(Ord1 f, Ord1 g) => Ord1 (Product f g) |
(Ord1 f, Ord1 g) => Ord1 (Sum f g) |

class Read1 f where

Lifting of the `Read` class to unary type constructors.

Methods

readsPrec1 :: Read a => Int -> ReadS (f a)

Instances

Read1 [] |
Read1 Identity |
Read1 Maybe |
Read a => Read1 (Either a) |
Read a => Read1 ((,) a) |
Read a => Read1 (Constant a) |
Read1 f => Read1 (Lift f) |
Read1 f => Read1 (IdentityT f) |
Read1 m => Read1 (ListT m) |
Read1 m => Read1 (MaybeT m) |
Read1 f => Read1 (Backwards f) |
Read1 f => Read1 (Reverse f) |
(Read e, Read1 m) => Read1 (ExceptT e m) |
(Read e, Read1 m) => Read1 (ErrorT e m) |
(Read w, Read1 m) => Read1 (WriterT w m) |
(Read w, Read1 m) => Read1 (WriterT w m) |
(Functor f, Read1 f, Read1 g) => Read1 (Compose f g) |
(Read1 f, Read1 g) => Read1 (Product f g) |
(Read1 f, Read1 g) => Read1 (Sum f g) |

class Show1 f where

Lifting of the `Show` class to unary type constructors.

Methods

showsPrec1 :: Show a => Int -> f a -> ShowS

Instances

Show1 [] |
Show1 Identity |
Show1 Maybe |
Show a => Show1 (Either a) |
Show a => Show1 ((,) a) |
Show a => Show1 (Constant a) |
Show1 f => Show1 (Lift f) |
Show1 f => Show1 (IdentityT f) |
Show1 m => Show1 (ListT m) |
Show1 m => Show1 (MaybeT m) |
Show1 f => Show1 (Backwards f) |
Show1 f => Show1 (Reverse f) |
(Show e, Show1 m) => Show1 (ExceptT e m) |
(Show e, Show1 m) => Show1 (ErrorT e m) |
(Show w, Show1 m) => Show1 (WriterT w m) |
(Show w, Show1 m) => Show1 (WriterT w m) |
(Functor f, Show1 f, Show1 g) => Show1 (Compose f g) |
(Show1 f, Show1 g) => Show1 (Product f g) |
(Show1 f, Show1 g) => Show1 (Sum f g) |

# Helper functions

readsData :: (String -> ReadS a) -> Int -> ReadS a

``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 with `readsUnary`, `readsUnary1` and `readsBinary1`, and combined with `mappend` from the `Monoid` class.

readsUnary :: Read a => String -> (a -> t) -> String -> ReadS t

``readsUnary` n c n'` matches the name of a unary data constructor and then parses its argument using `readsPrec`.

readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t

``readsUnary1` n c n'` matches the name of a unary data constructor and then parses its argument using `readsPrec1`.

readsBinary1 :: (Read1 f, Read1 g, Read a) => String -> (f a -> g a -> t) -> String -> ReadS t

``readsBinary1` n c n'` matches the name of a binary data constructor and then parses its arguments using `readsPrec1`.

showsUnary :: Show a => String -> Int -> a -> ShowS

``showsUnary` n d x` produces the string representation of a unary data constructor with name `n` and argument `x`, in precedence context `d`.

showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS

``showsUnary1` n d x` produces the string representation of a unary data constructor with name `n` and argument `x`, in precedence context `d`.

showsBinary1 :: (Show1 f, Show1 g, Show a) => String -> Int -> f a -> g a -> ShowS

``showsBinary1` n d x` produces the string representation of a binary data constructor with name `n` and arguments `x` and `y`, in precedence context `d`.