W3cubDocs

/Haskell 8

GHC.Generics

Copyright (c) Universiteit Utrecht 2010-2011, University of Oxford 2012-2014
License see libraries/base/LICENSE
Maintainer [email protected]
Stability internal
Portability non-portable
Safe Haskell Trustworthy
Language Haskell2010

Description

If you're using GHC.Generics, you should consider using the http://hackage.haskell.org/package/generic-deriving package, which contains many useful generic functions.

Since: 4.6.0.0

Introduction

Datatype-generic functions are based on the idea of converting values of a datatype T into corresponding values of a (nearly) isomorphic type Rep T. The type Rep T is built from a limited set of type constructors, all provided by this module. A datatype-generic function is then an overloaded function with instances for most of these type constructors, together with a wrapper that performs the mapping between T and Rep T. By using this technique, we merely need a few generic instances in order to implement functionality that works for any representable type.

Representable types are collected in the Generic class, which defines the associated type Rep as well as conversion functions from and to. Typically, you will not define Generic instances by hand, but have the compiler derive them for you.

Representing datatypes

The key to defining your own datatype-generic functions is to understand how to represent datatypes using the given set of type constructors.

Let us look at an example first:

data Tree a = Leaf a | Node (Tree a) (Tree a)
  deriving Generic

The above declaration (which requires the language pragma DeriveGeneric) causes the following representation to be generated:

instance Generic (Tree a) where
  type Rep (Tree a) =
    D1 ('MetaData "Tree" "Main" "package-name" 'False)
      (C1 ('MetaCons "Leaf" 'PrefixI 'False)
         (S1 '(MetaSel 'Nothing
                          'NoSourceUnpackedness
                          'NoSourceStrictness
                          'DecidedLazy)
                (Rec0 a))
       :+:
       C1 ('MetaCons "Node" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec0 (Tree a))
          :*:
          S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec0 (Tree a))))
  ...

Hint: You can obtain information about the code being generated from GHC by passing the -ddump-deriv flag. In GHCi, you can expand a type family such as Rep using the :kind! command.

This is a lot of information! However, most of it is actually merely meta-information that makes names of datatypes and constructors and more available on the type level.

Here is a reduced representation for Tree with nearly all meta-information removed, for now keeping only the most essential aspects:

instance Generic (Tree a) where
  type Rep (Tree a) =
    Rec0 a
    :+:
    (Rec0 (Tree a) :*: Rec0 (Tree a))

The Tree datatype has two constructors. The representation of individual constructors is combined using the binary type constructor :+:.

The first constructor consists of a single field, which is the parameter a. This is represented as Rec0 a.

The second constructor consists of two fields. Each is a recursive field of type Tree a, represented as Rec0 (Tree a). Representations of individual fields are combined using the binary type constructor :*:.

Now let us explain the additional tags being used in the complete representation:

  • The S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) tag indicates several things. The 'Nothing indicates that there is no record field selector associated with this field of the constructor (if there were, it would have been marked 'Just "recordName" instead). The other types contain meta-information on the field's strictness:
  • There is no {-# UNPACK #-} or {-# NOUNPACK #-} annotation in the source, so it is tagged with 'NoSourceUnpackedness.
  • There is no strictness (!) or laziness (~) annotation in the source, so it is tagged with 'NoSourceStrictness.
  • The compiler infers that the field is lazy, so it is tagged with 'DecidedLazy. Bear in mind that what the compiler decides may be quite different from what is written in the source. See DecidedStrictness for a more detailed explanation.

The 'MetaSel type is also an instance of the type class Selector, which can be used to obtain information about the field at the value level.

  • The C1 ('MetaCons "Leaf" 'PrefixI 'False) and C1 ('MetaCons "Node" 'PrefixI 'False) invocations indicate that the enclosed part is the representation of the first and second constructor of datatype Tree, respectively. Here, the meta-information regarding constructor names, fixity and whether it has named fields or not is encoded at the type level. The 'MetaCons type is also an instance of the type class Constructor. This type class can be used to obtain information about the constructor at the value level.
  • The D1 ('MetaData "Tree" "Main" "package-name" 'False) tag indicates that the enclosed part is the representation of the datatype Tree. Again, the meta-information is encoded at the type level. The 'MetaData type is an instance of class Datatype, which can be used to obtain the name of a datatype, the module it has been defined in, the package it is located under, and whether it has been defined using data or newtype at the value level.

Derived and fundamental representation types

There are many datatype-generic functions that do not distinguish between positions that are parameters or positions that are recursive calls. There are also many datatype-generic functions that do not care about the names of datatypes and constructors at all. To keep the number of cases to consider in generic functions in such a situation to a minimum, it turns out that many of the type constructors introduced above are actually synonyms, defining them to be variants of a smaller set of constructors.

Individual fields of constructors: K1

The type constructor Rec0 is a variant of K1:

type Rec0 = K1 R

Here, R is a type-level proxy that does not have any associated values.

There used to be another variant of K1 (namely Par0), but it has since been deprecated.

Meta information: M1

The type constructors S1, C1 and D1 are all variants of M1:

type S1 = M1 S
type C1 = M1 C
type D1 = M1 D

The types S, C and D are once again type-level proxies, just used to create several variants of M1.

Additional generic representation type constructors

Next to K1, M1, :+: and :*: there are a few more type constructors that occur in the representations of other datatypes.

Empty datatypes: V1

For empty datatypes, V1 is used as a representation. For example,

data Empty deriving Generic

yields

instance Generic Empty where
  type Rep Empty =
    D1 ('MetaData "Empty" "Main" "package-name" 'False) V1
Constructors without fields: U1

If a constructor has no arguments, then U1 is used as its representation. For example the representation of Bool is

instance Generic Bool where
  type Rep Bool =
    D1 ('MetaData "Bool" "Data.Bool" "package-name" 'False)
      (C1 ('MetaCons "False" 'PrefixI 'False) U1 :+: C1 ('MetaCons "True" 'PrefixI 'False) U1)

Representation of types with many constructors or many fields

As :+: and :*: are just binary operators, one might ask what happens if the datatype has more than two constructors, or a constructor with more than two fields. The answer is simple: the operators are used several times, to combine all the constructors and fields as needed. However, users /should not rely on a specific nesting strategy/ for :+: and :*: being used. The compiler is free to choose any nesting it prefers. (In practice, the current implementation tries to produce a more or less balanced nesting, so that the traversal of the structure of the datatype from the root to a particular component can be performed in logarithmic rather than linear time.)

Defining datatype-generic functions

A datatype-generic function comprises two parts:

  1. Generic instances for the function, implementing it for most of the representation type constructors introduced above.
  2. A wrapper that for any datatype that is in Generic, performs the conversion between the original value and its Rep-based representation and then invokes the generic instances.

As an example, let us look at a function encode that produces a naive, but lossless bit encoding of values of various datatypes. So we are aiming to define a function

encode :: Generic a => a -> [Bool]

where we use Bool as our datatype for bits.

For part 1, we define a class Encode'. Perhaps surprisingly, this class is parameterized over a type constructor f of kind * -> *. This is a technicality: all the representation type constructors operate with kind * -> * as base kind. But the type argument is never being used. This may be changed at some point in the future. The class has a single method, and we use the type we want our final function to have, but we replace the occurrences of the generic type argument a with f p (where the p is any argument; it will not be used).

class Encode' f where
  encode' :: f p -> [Bool]

With the goal in mind to make encode work on Tree and other datatypes, we now define instances for the representation type constructors V1, U1, :+:, :*:, K1, and M1.

Definition of the generic representation types

In order to be able to do this, we need to know the actual definitions of these types:

data    V1        p                       -- lifted version of Empty
data    U1        p = U1                  -- lifted version of ()
data    (:+:) f g p = L1 (f p) | R1 (g p) -- lifted version of Either
data    (:*:) f g p = (f p) :*: (g p)     -- lifted version of (,)
newtype K1    i c p = K1 { unK1 :: c }    -- a container for a c
newtype M1  i t f p = M1 { unM1 :: f p }  -- a wrapper

So, U1 is just the unit type, :+: is just a binary choice like Either, :*: is a binary pair like the pair constructor (,), and K1 is a value of a specific type c, and M1 wraps a value of the generic type argument, which in the lifted world is an f p (where we do not care about p).

Generic instances

The instance for V1 is slightly awkward (but also rarely used):

instance Encode' V1 where
  encode' x = undefined

There are no values of type V1 p to pass (except undefined), so this is actually impossible. One can ask why it is useful to define an instance for V1 at all in this case? Well, an empty type can be used as an argument to a non-empty type, and you might still want to encode the resulting type. As a somewhat contrived example, consider [Empty], which is not an empty type, but contains just the empty list. The V1 instance ensures that we can call the generic function on such types.

There is exactly one value of type U1, so encoding it requires no knowledge, and we can use zero bits:

instance Encode' U1 where
  encode' U1 = []

In the case for :+:, we produce False or True depending on whether the constructor of the value provided is located on the left or on the right:

instance (Encode' f, Encode' g) => Encode' (f :+: g) where
  encode' (L1 x) = False : encode' x
  encode' (R1 x) = True  : encode' x

In the case for :*:, we append the encodings of the two subcomponents:

instance (Encode' f, Encode' g) => Encode' (f :*: g) where
  encode' (x :*: y) = encode' x ++ encode' y

The case for K1 is rather interesting. Here, we call the final function encode that we yet have to define, recursively. We will use another type class Encode for that function:

instance (Encode c) => Encode' (K1 i c) where
  encode' (K1 x) = encode x

Note how Par0 and Rec0 both being mapped to K1 allows us to define a uniform instance here.

Similarly, we can define a uniform instance for M1, because we completely disregard all meta-information:

instance (Encode' f) => Encode' (M1 i t f) where
  encode' (M1 x) = encode' x

Unlike in K1, the instance for M1 refers to encode', not encode.

The wrapper and generic default

We now define class Encode for the actual encode function:

class Encode a where
  encode :: a -> [Bool]
  default encode :: (Generic a, Encode' (Rep a)) => a -> [Bool]
  encode x = encode' (from x)

The incoming x is converted using from, then we dispatch to the generic instances using encode'. We use this as a default definition for encode. We need the 'default encode' signature because ordinary Haskell default methods must not introduce additional class constraints, but our generic default does.

Defining a particular instance is now as simple as saying

instance (Encode a) => Encode (Tree a)

Omitting generic instances

It is not always required to provide instances for all the generic representation types, but omitting instances restricts the set of datatypes the functions will work for:

  • If no :+: instance is given, the function may still work for empty datatypes or datatypes that have a single constructor, but will fail on datatypes with more than one constructor.
  • If no :*: instance is given, the function may still work for datatypes where each constructor has just zero or one field, in particular for enumeration types.
  • If no K1 instance is given, the function may still work for enumeration types, where no constructor has any fields.
  • If no V1 instance is given, the function may still work for any datatype that is not empty.
  • If no U1 instance is given, the function may still work for any datatype where each constructor has at least one field.

An M1 instance is always required (but it can just ignore the meta-information, as is the case for encode above).

Generic constructor classes

Datatype-generic functions as defined above work for a large class of datatypes, including parameterized datatypes. (We have used Tree as our example above, which is of kind * -> *.) However, the Generic class ranges over types of kind *, and therefore, the resulting generic functions (such as encode) must be parameterized by a generic type argument of kind *.

What if we want to define generic classes that range over type constructors (such as Functor, Traversable, or Foldable)?

The Generic1 class

Like Generic, there is a class Generic1 that defines a representation Rep1 and conversion functions from1 and to1, only that Generic1 ranges over types of kind * -> *. The Generic1 class is also derivable.

The representation Rep1 is ever so slightly different from Rep. Let us look at Tree as an example again:

data Tree a = Leaf a | Node (Tree a) (Tree a)
  deriving Generic1

The above declaration causes the following representation to be generated:

instance Generic1 Tree where
  type Rep1 Tree =
    D1 ('MetaData "Tree" "Main" "package-name" 'False)
      (C1 ('MetaCons "Leaf" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               Par1)
       :+:
       C1 ('MetaCons "Node" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec1 Tree)
          :*:
          S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec1 Tree)))
  ...

The representation reuses D1, C1, S1 (and thereby M1) as well as :+: and :*: from Rep. (This reusability is the reason that we carry around the dummy type argument for kind-*-types, but there are already enough different names involved without duplicating each of these.)

What's different is that we now use Par1 to refer to the parameter (and that parameter, which used to be a), is not mentioned explicitly by name anywhere; and we use Rec1 to refer to a recursive use of Tree a.

Representation of * -> * types

Unlike Rec0, the Par1 and Rec1 type constructors do not map to K1. They are defined directly, as follows:

newtype Par1   p = Par1 { unPar1 ::   p } -- gives access to parameter p
newtype Rec1 f p = Rec1 { unRec1 :: f p } -- a wrapper

In Par1, the parameter p is used for the first time, whereas Rec1 simply wraps an application of f to p.

Note that K1 (in the guise of Rec0) can still occur in a Rep1 representation, namely when the datatype has a field that does not mention the parameter.

The declaration

data WithInt a = WithInt Int a
  deriving Generic1

yields

class Rep1 WithInt where
  type Rep1 WithInt =
    D1 ('MetaData "WithInt" "Main" "package-name" 'False)
      (C1 ('MetaCons "WithInt" 'PrefixI 'False)
        (S1 ('MetaSel 'Nothing
                        'NoSourceUnpackedness
                        'NoSourceStrictness
                        'DecidedLazy)
              (Rec0 Int)
         :*:
         S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
              Par1))

If the parameter a appears underneath a composition of other type constructors, then the representation involves composition, too:

data Rose a = Fork a [Rose a]

yields

class Rep1 Rose where
  type Rep1 Rose =
    D1 ('MetaData "Rose" "Main" "package-name" 'False)
      (C1 ('MetaCons "Fork" 'PrefixI 'False)
        (S1 ('MetaSel 'Nothing
                        'NoSourceUnpackedness
                        'NoSourceStrictness
                        'DecidedLazy)
              Par1
         :*:
         S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
              ([] :.: Rec1 Rose)))

where

newtype (:.:) f g p = Comp1 { unComp1 :: f (g p) }

Representation of unlifted types

If one were to attempt to derive a Generic instance for a datatype with an unlifted argument (for example, Int#), one might expect the occurrence of the Int# argument to be marked with Rec0 Int#. This won't work, though, since Int# is of kind # and Rec0 expects a type of kind *. In fact, polymorphism over unlifted types is disallowed completely.

One solution would be to represent an occurrence of Int# with 'Rec0 Int' instead. With this approach, however, the programmer has no way of knowing whether the Int is actually an Int# in disguise.

Instead of reusing Rec0, a separate data family URec is used to mark occurrences of common unlifted types:

data family URec a p

data instance URec (Ptr ()) p = UAddr   { uAddr#   :: Addr#   }
data instance URec Char     p = UChar   { uChar#   :: Char#   }
data instance URec Double   p = UDouble { uDouble# :: Double# }
data instance URec Int      p = UFloat  { uFloat#  :: Float#  }
data instance URec Float    p = UInt    { uInt#    :: Int#    }
data instance URec Word     p = UWord   { uWord#   :: Word#   }

Several type synonyms are provided for convenience:

type UAddr   = URec (Ptr ())
type UChar   = URec Char
type UDouble = URec Double
type UFloat  = URec Float
type UInt    = URec Int
type UWord   = URec Word

The declaration

data IntHash = IntHash Int#
  deriving Generic

yields

instance Generic IntHash where
  type Rep IntHash =
    D1 ('MetaData "IntHash" "Main" "package-name" 'False)
      (C1 ('MetaCons "IntHash" 'PrefixI 'False)
        (S1 ('MetaSel 'Nothing
                        'NoSourceUnpackedness
                        'NoSourceStrictness
                        'DecidedLazy)
              UInt))

Currently, only the six unlifted types listed above are generated, but this may be extended to encompass more unlifted types in the future.

Generic representation types

data V1 p Source

Void: used for datatypes without constructors

Instances

Functor V1

Methods

fmap :: (a -> b) -> V1 a -> V1 b Source

(<$) :: a -> V1 b -> V1 a Source

Foldable V1

Methods

fold :: Monoid m => V1 m -> m Source

foldMap :: Monoid m => (a -> m) -> V1 a -> m Source

foldr :: (a -> b -> b) -> b -> V1 a -> b Source

foldr' :: (a -> b -> b) -> b -> V1 a -> b Source

foldl :: (b -> a -> b) -> b -> V1 a -> b Source

foldl' :: (b -> a -> b) -> b -> V1 a -> b Source

foldr1 :: (a -> a -> a) -> V1 a -> a Source

foldl1 :: (a -> a -> a) -> V1 a -> a Source

toList :: V1 a -> [a] Source

null :: V1 a -> Bool Source

length :: V1 a -> Int Source

elem :: Eq a => a -> V1 a -> Bool Source

maximum :: Ord a => V1 a -> a Source

minimum :: Ord a => V1 a -> a Source

sum :: Num a => V1 a -> a Source

product :: Num a => V1 a -> a Source

Traversable V1

Methods

traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) Source

sequenceA :: Applicative f => V1 (f a) -> f (V1 a) Source

mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) Source

sequence :: Monad m => V1 (m a) -> m (V1 a) Source

Generic1 V1

Associated Types

type Rep1 (V1 :: * -> *) :: * -> * Source

Methods

from1 :: V1 a -> Rep1 V1 a Source

to1 :: Rep1 V1 a -> V1 a Source

Eq (V1 p)

Methods

(==) :: V1 p -> V1 p -> Bool Source

(/=) :: V1 p -> V1 p -> Bool Source

Data p => Data (V1 p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 p) Source

toConstr :: V1 p -> Constr Source

dataTypeOf :: V1 p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (V1 p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 p)) Source

gmapT :: (forall b. Data b => b -> b) -> V1 p -> V1 p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> V1 p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) Source

Ord (V1 p)

Methods

compare :: V1 p -> V1 p -> Ordering Source

(<) :: V1 p -> V1 p -> Bool Source

(<=) :: V1 p -> V1 p -> Bool Source

(>) :: V1 p -> V1 p -> Bool Source

(>=) :: V1 p -> V1 p -> Bool Source

max :: V1 p -> V1 p -> V1 p Source

min :: V1 p -> V1 p -> V1 p Source

Read (V1 p)
Show (V1 p)

Methods

showsPrec :: Int -> V1 p -> ShowS Source

show :: V1 p -> String Source

showList :: [V1 p] -> ShowS Source

Generic (V1 p)

Associated Types

type Rep (V1 p) :: * -> * Source

Methods

from :: V1 p -> Rep (V1 p) x Source

to :: Rep (V1 p) x -> V1 p Source

type Rep1 V1
type Rep1 V1 = D1 (MetaData "V1" "GHC.Generics" "base" False) V1
type Rep (V1 p)
type Rep (V1 p) = D1 (MetaData "V1" "GHC.Generics" "base" False) V1

data U1 p Source

Unit: used for constructors without arguments

Constructors

U1

Instances

Monad U1

Methods

(>>=) :: U1 a -> (a -> U1 b) -> U1 b Source

(>>) :: U1 a -> U1 b -> U1 b Source

return :: a -> U1 a Source

fail :: String -> U1 a Source

Functor U1

Methods

fmap :: (a -> b) -> U1 a -> U1 b Source

(<$) :: a -> U1 b -> U1 a Source

Applicative U1

Methods

pure :: a -> U1 a Source

(<*>) :: U1 (a -> b) -> U1 a -> U1 b Source

(*>) :: U1 a -> U1 b -> U1 b Source

(<*) :: U1 a -> U1 b -> U1 a Source

Foldable U1

Methods

fold :: Monoid m => U1 m -> m Source

foldMap :: Monoid m => (a -> m) -> U1 a -> m Source

foldr :: (a -> b -> b) -> b -> U1 a -> b Source

foldr' :: (a -> b -> b) -> b -> U1 a -> b Source

foldl :: (b -> a -> b) -> b -> U1 a -> b Source

foldl' :: (b -> a -> b) -> b -> U1 a -> b Source

foldr1 :: (a -> a -> a) -> U1 a -> a Source

foldl1 :: (a -> a -> a) -> U1 a -> a Source

toList :: U1 a -> [a] Source

null :: U1 a -> Bool Source

length :: U1 a -> Int Source

elem :: Eq a => a -> U1 a -> Bool Source

maximum :: Ord a => U1 a -> a Source

minimum :: Ord a => U1 a -> a Source

sum :: Num a => U1 a -> a Source

product :: Num a => U1 a -> a Source

Traversable U1

Methods

traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) Source

sequenceA :: Applicative f => U1 (f a) -> f (U1 a) Source

mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) Source

sequence :: Monad m => U1 (m a) -> m (U1 a) Source

Generic1 U1

Associated Types

type Rep1 (U1 :: * -> *) :: * -> * Source

Methods

from1 :: U1 a -> Rep1 U1 a Source

to1 :: Rep1 U1 a -> U1 a Source

MonadPlus U1

Methods

mzero :: U1 a Source

mplus :: U1 a -> U1 a -> U1 a Source

Alternative U1

Methods

empty :: U1 a Source

(<|>) :: U1 a -> U1 a -> U1 a Source

some :: U1 a -> U1 [a] Source

many :: U1 a -> U1 [a] Source

MonadZip U1

Methods

mzip :: U1 a -> U1 b -> U1 (a, b) Source

mzipWith :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source

munzip :: U1 (a, b) -> (U1 a, U1 b) Source

Eq (U1 p)

Methods

(==) :: U1 p -> U1 p -> Bool Source

(/=) :: U1 p -> U1 p -> Bool Source

Data p => Data (U1 p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 p -> c (U1 p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 p) Source

toConstr :: U1 p -> Constr Source

dataTypeOf :: U1 p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (U1 p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 p)) Source

gmapT :: (forall b. Data b => b -> b) -> U1 p -> U1 p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> U1 p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) Source

Ord (U1 p)

Methods

compare :: U1 p -> U1 p -> Ordering Source

(<) :: U1 p -> U1 p -> Bool Source

(<=) :: U1 p -> U1 p -> Bool Source

(>) :: U1 p -> U1 p -> Bool Source

(>=) :: U1 p -> U1 p -> Bool Source

max :: U1 p -> U1 p -> U1 p Source

min :: U1 p -> U1 p -> U1 p Source

Read (U1 p)
Show (U1 p)

Methods

showsPrec :: Int -> U1 p -> ShowS Source

show :: U1 p -> String Source

showList :: [U1 p] -> ShowS Source

Generic (U1 p)

Associated Types

type Rep (U1 p) :: * -> * Source

Methods

from :: U1 p -> Rep (U1 p) x Source

to :: Rep (U1 p) x -> U1 p Source

type Rep1 U1
type Rep1 U1 = D1 (MetaData "U1" "GHC.Generics" "base" False) (C1 (MetaCons "U1" PrefixI False) U1)
type Rep (U1 p)
type Rep (U1 p) = D1 (MetaData "U1" "GHC.Generics" "base" False) (C1 (MetaCons "U1" PrefixI False) U1)

newtype Par1 p Source

Used for marking occurrences of the parameter

Constructors

Par1

Fields

Instances

Monad Par1

Methods

(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b Source

(>>) :: Par1 a -> Par1 b -> Par1 b Source

return :: a -> Par1 a Source

fail :: String -> Par1 a Source

Functor Par1

Methods

fmap :: (a -> b) -> Par1 a -> Par1 b Source

(<$) :: a -> Par1 b -> Par1 a Source

MonadFix Par1

Methods

mfix :: (a -> Par1 a) -> Par1 a Source

Applicative Par1

Methods

pure :: a -> Par1 a Source

(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source

(*>) :: Par1 a -> Par1 b -> Par1 b Source

(<*) :: Par1 a -> Par1 b -> Par1 a Source

Foldable Par1

Methods

fold :: Monoid m => Par1 m -> m Source

foldMap :: Monoid m => (a -> m) -> Par1 a -> m Source

foldr :: (a -> b -> b) -> b -> Par1 a -> b Source

foldr' :: (a -> b -> b) -> b -> Par1 a -> b Source

foldl :: (b -> a -> b) -> b -> Par1 a -> b Source

foldl' :: (b -> a -> b) -> b -> Par1 a -> b Source

foldr1 :: (a -> a -> a) -> Par1 a -> a Source

foldl1 :: (a -> a -> a) -> Par1 a -> a Source

toList :: Par1 a -> [a] Source

null :: Par1 a -> Bool Source

length :: Par1 a -> Int Source

elem :: Eq a => a -> Par1 a -> Bool Source

maximum :: Ord a => Par1 a -> a Source

minimum :: Ord a => Par1 a -> a Source

sum :: Num a => Par1 a -> a Source

product :: Num a => Par1 a -> a Source

Traversable Par1

Methods

traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) Source

sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) Source

mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) Source

sequence :: Monad m => Par1 (m a) -> m (Par1 a) Source

Generic1 Par1

Associated Types

type Rep1 (Par1 :: * -> *) :: * -> * Source

Methods

from1 :: Par1 a -> Rep1 Par1 a Source

to1 :: Rep1 Par1 a -> Par1 a Source

MonadZip Par1

Methods

mzip :: Par1 a -> Par1 b -> Par1 (a, b) Source

mzipWith :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source

munzip :: Par1 (a, b) -> (Par1 a, Par1 b) Source

Eq p => Eq (Par1 p)

Methods

(==) :: Par1 p -> Par1 p -> Bool Source

(/=) :: Par1 p -> Par1 p -> Bool Source

Data p => Data (Par1 p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Par1 p) Source

toConstr :: Par1 p -> Constr Source

dataTypeOf :: Par1 p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Par1 p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Par1 p)) Source

gmapT :: (forall b. Data b => b -> b) -> Par1 p -> Par1 p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Par1 p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Par1 p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source

Ord p => Ord (Par1 p)

Methods

compare :: Par1 p -> Par1 p -> Ordering Source

(<) :: Par1 p -> Par1 p -> Bool Source

(<=) :: Par1 p -> Par1 p -> Bool Source

(>) :: Par1 p -> Par1 p -> Bool Source

(>=) :: Par1 p -> Par1 p -> Bool Source

max :: Par1 p -> Par1 p -> Par1 p Source

min :: Par1 p -> Par1 p -> Par1 p Source

Read p => Read (Par1 p)
Show p => Show (Par1 p)

Methods

showsPrec :: Int -> Par1 p -> ShowS Source

show :: Par1 p -> String Source

showList :: [Par1 p] -> ShowS Source

Generic (Par1 p)

Associated Types

type Rep (Par1 p) :: * -> * Source

Methods

from :: Par1 p -> Rep (Par1 p) x Source

to :: Rep (Par1 p) x -> Par1 p Source

type Rep1 Par1
type Rep1 Par1 = D1 (MetaData "Par1" "GHC.Generics" "base" True) (C1 (MetaCons "Par1" PrefixI True) (S1 (MetaSel (Just Symbol "unPar1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))
type Rep (Par1 p)
type Rep (Par1 p) = D1 (MetaData "Par1" "GHC.Generics" "base" True) (C1 (MetaCons "Par1" PrefixI True) (S1 (MetaSel (Just Symbol "unPar1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 p)))

newtype Rec1 f p Source

Recursive calls of kind * -> *

Constructors

Rec1

Fields

Instances

Monad f => Monad (Rec1 f)

Methods

(>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b Source

(>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source

return :: a -> Rec1 f a Source

fail :: String -> Rec1 f a Source

Functor f => Functor (Rec1 f)

Methods

fmap :: (a -> b) -> Rec1 f a -> Rec1 f b Source

(<$) :: a -> Rec1 f b -> Rec1 f a Source

MonadFix f => MonadFix (Rec1 f)

Methods

mfix :: (a -> Rec1 f a) -> Rec1 f a Source

Applicative f => Applicative (Rec1 f)

Methods

pure :: a -> Rec1 f a Source

(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source

(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source

(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source

Foldable f => Foldable (Rec1 f)

Methods

fold :: Monoid m => Rec1 f m -> m Source

foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m Source

foldr :: (a -> b -> b) -> b -> Rec1 f a -> b Source

foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b Source

foldl :: (b -> a -> b) -> b -> Rec1 f a -> b Source

foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b Source

foldr1 :: (a -> a -> a) -> Rec1 f a -> a Source

foldl1 :: (a -> a -> a) -> Rec1 f a -> a Source

toList :: Rec1 f a -> [a] Source

null :: Rec1 f a -> Bool Source

length :: Rec1 f a -> Int Source

elem :: Eq a => a -> Rec1 f a -> Bool Source

maximum :: Ord a => Rec1 f a -> a Source

minimum :: Ord a => Rec1 f a -> a Source

sum :: Num a => Rec1 f a -> a Source

product :: Num a => Rec1 f a -> a Source

Traversable f => Traversable (Rec1 f)

Methods

traverse :: Applicative f => (a -> f b) -> Rec1 f a -> f (Rec1 f b) Source

sequenceA :: Applicative f => Rec1 f (f a) -> f (Rec1 f a) Source

mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) Source

sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) Source

Generic1 (Rec1 f)

Associated Types

type Rep1 (Rec1 f :: * -> *) :: * -> * Source

Methods

from1 :: Rec1 f a -> Rep1 (Rec1 f) a Source

to1 :: Rep1 (Rec1 f) a -> Rec1 f a Source

MonadPlus f => MonadPlus (Rec1 f)

Methods

mzero :: Rec1 f a Source

mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a Source

Alternative f => Alternative (Rec1 f)

Methods

empty :: Rec1 f a Source

(<|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a Source

some :: Rec1 f a -> Rec1 f [a] Source

many :: Rec1 f a -> Rec1 f [a] Source

MonadZip f => MonadZip (Rec1 f)

Methods

mzip :: Rec1 f a -> Rec1 f b -> Rec1 f (a, b) Source

mzipWith :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source

munzip :: Rec1 f (a, b) -> (Rec1 f a, Rec1 f b) Source

Eq (f p) => Eq (Rec1 f p)

Methods

(==) :: Rec1 f p -> Rec1 f p -> Bool Source

(/=) :: Rec1 f p -> Rec1 f p -> Bool Source

(Data (f p), Typeable (* -> *) f, Data p) => Data (Rec1 f p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 f p -> c (Rec1 f p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 f p) Source

toConstr :: Rec1 f p -> Constr Source

dataTypeOf :: Rec1 f p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 f p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 f p)) Source

gmapT :: (forall b. Data b => b -> b) -> Rec1 f p -> Rec1 f p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Rec1 f p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 f p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) Source

Ord (f p) => Ord (Rec1 f p)

Methods

compare :: Rec1 f p -> Rec1 f p -> Ordering Source

(<) :: Rec1 f p -> Rec1 f p -> Bool Source

(<=) :: Rec1 f p -> Rec1 f p -> Bool Source

(>) :: Rec1 f p -> Rec1 f p -> Bool Source

(>=) :: Rec1 f p -> Rec1 f p -> Bool Source

max :: Rec1 f p -> Rec1 f p -> Rec1 f p Source

min :: Rec1 f p -> Rec1 f p -> Rec1 f p Source

Read (f p) => Read (Rec1 f p)
Show (f p) => Show (Rec1 f p)

Methods

showsPrec :: Int -> Rec1 f p -> ShowS Source

show :: Rec1 f p -> String Source

showList :: [Rec1 f p] -> ShowS Source

Generic (Rec1 f p)

Associated Types

type Rep (Rec1 f p) :: * -> * Source

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x Source

to :: Rep (Rec1 f p) x -> Rec1 f p Source

type Rep1 (Rec1 f)
type Rep1 (Rec1 f) = D1 (MetaData "Rec1" "GHC.Generics" "base" True) (C1 (MetaCons "Rec1" PrefixI True) (S1 (MetaSel (Just Symbol "unRec1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)))
type Rep (Rec1 f p)
type Rep (Rec1 f p) = D1 (MetaData "Rec1" "GHC.Generics" "base" True) (C1 (MetaCons "Rec1" PrefixI True) (S1 (MetaSel (Just Symbol "unRec1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f p))))

newtype K1 i c p Source

Constants, additional parameters and recursion of kind *

Constructors

K1

Fields

Instances

Bifunctor (K1 i)

Methods

bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d Source

first :: (a -> b) -> K1 i a c -> K1 i b c Source

second :: (b -> c) -> K1 i a b -> K1 i a c Source

Functor (K1 i c)

Methods

fmap :: (a -> b) -> K1 i c a -> K1 i c b Source

(<$) :: a -> K1 i c b -> K1 i c a Source

Foldable (K1 i c)

Methods

fold :: Monoid m => K1 i c m -> m Source

foldMap :: Monoid m => (a -> m) -> K1 i c a -> m Source

foldr :: (a -> b -> b) -> b -> K1 i c a -> b Source

foldr' :: (a -> b -> b) -> b -> K1 i c a -> b Source

foldl :: (b -> a -> b) -> b -> K1 i c a -> b Source

foldl' :: (b -> a -> b) -> b -> K1 i c a -> b Source

foldr1 :: (a -> a -> a) -> K1 i c a -> a Source

foldl1 :: (a -> a -> a) -> K1 i c a -> a Source

toList :: K1 i c a -> [a] Source

null :: K1 i c a -> Bool Source

length :: K1 i c a -> Int Source

elem :: Eq a => a -> K1 i c a -> Bool Source

maximum :: Ord a => K1 i c a -> a Source

minimum :: Ord a => K1 i c a -> a Source

sum :: Num a => K1 i c a -> a Source

product :: Num a => K1 i c a -> a Source

Traversable (K1 i c)

Methods

traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) Source

sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) Source

mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) Source

sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) Source

Generic1 (K1 i c)

Associated Types

type Rep1 (K1 i c :: * -> *) :: * -> * Source

Methods

from1 :: K1 i c a -> Rep1 (K1 i c) a Source

to1 :: Rep1 (K1 i c) a -> K1 i c a Source

Eq c => Eq (K1 i c p)

Methods

(==) :: K1 i c p -> K1 i c p -> Bool Source

(/=) :: K1 i c p -> K1 i c p -> Bool Source

(Typeable * i, Data p, Data c) => Data (K1 i c p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> K1 i c p -> c (K1 i c p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (K1 i c p) Source

toConstr :: K1 i c p -> Constr Source

dataTypeOf :: K1 i c p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (K1 i c p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (K1 i c p)) Source

gmapT :: (forall b. Data b => b -> b) -> K1 i c p -> K1 i c p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> K1 i c p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 i c p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) Source

Ord c => Ord (K1 i c p)

Methods

compare :: K1 i c p -> K1 i c p -> Ordering Source

(<) :: K1 i c p -> K1 i c p -> Bool Source

(<=) :: K1 i c p -> K1 i c p -> Bool Source

(>) :: K1 i c p -> K1 i c p -> Bool Source

(>=) :: K1 i c p -> K1 i c p -> Bool Source

max :: K1 i c p -> K1 i c p -> K1 i c p Source

min :: K1 i c p -> K1 i c p -> K1 i c p Source

Read c => Read (K1 i c p)

Methods

readsPrec :: Int -> ReadS (K1 i c p) Source

readList :: ReadS [K1 i c p] Source

readPrec :: ReadPrec (K1 i c p) Source

readListPrec :: ReadPrec [K1 i c p] Source

Show c => Show (K1 i c p)

Methods

showsPrec :: Int -> K1 i c p -> ShowS Source

show :: K1 i c p -> String Source

showList :: [K1 i c p] -> ShowS Source

Generic (K1 i c p)

Associated Types

type Rep (K1 i c p) :: * -> * Source

Methods

from :: K1 i c p -> Rep (K1 i c p) x Source

to :: Rep (K1 i c p) x -> K1 i c p Source

type Rep1 (K1 i c)
type Rep1 (K1 i c) = D1 (MetaData "K1" "GHC.Generics" "base" True) (C1 (MetaCons "K1" PrefixI True) (S1 (MetaSel (Just Symbol "unK1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))
type Rep (K1 i c p)
type Rep (K1 i c p) = D1 (MetaData "K1" "GHC.Generics" "base" True) (C1 (MetaCons "K1" PrefixI True) (S1 (MetaSel (Just Symbol "unK1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))

newtype M1 i c f p Source

Meta-information (constructor names, etc.)

Constructors

M1

Fields

Instances

Monad f => Monad (M1 i c f)

Methods

(>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b Source

(>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source

return :: a -> M1 i c f a Source

fail :: String -> M1 i c f a Source

Functor f => Functor (M1 i c f)

Methods

fmap :: (a -> b) -> M1 i c f a -> M1 i c f b Source

(<$) :: a -> M1 i c f b -> M1 i c f a Source

MonadFix f => MonadFix (M1 i c f)

Methods

mfix :: (a -> M1 i c f a) -> M1 i c f a Source

Applicative f => Applicative (M1 i c f)

Methods

pure :: a -> M1 i c f a Source

(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b Source

(*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source

(<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a Source

Foldable f => Foldable (M1 i c f)

Methods

fold :: Monoid m => M1 i c f m -> m Source

foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m Source

foldr :: (a -> b -> b) -> b -> M1 i c f a -> b Source

foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b Source

foldl :: (b -> a -> b) -> b -> M1 i c f a -> b Source

foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b Source

foldr1 :: (a -> a -> a) -> M1 i c f a -> a Source

foldl1 :: (a -> a -> a) -> M1 i c f a -> a Source

toList :: M1 i c f a -> [a] Source

null :: M1 i c f a -> Bool Source

length :: M1 i c f a -> Int Source

elem :: Eq a => a -> M1 i c f a -> Bool Source

maximum :: Ord a => M1 i c f a -> a Source

minimum :: Ord a => M1 i c f a -> a Source

sum :: Num a => M1 i c f a -> a Source

product :: Num a => M1 i c f a -> a Source

Traversable f => Traversable (M1 i c f)

Methods

traverse :: Applicative f => (a -> f b) -> M1 i c f a -> f (M1 i c f b) Source

sequenceA :: Applicative f => M1 i c f (f a) -> f (M1 i c f a) Source

mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) Source

sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) Source

Generic1 (M1 i c f)

Associated Types

type Rep1 (M1 i c f :: * -> *) :: * -> * Source

Methods

from1 :: M1 i c f a -> Rep1 (M1 i c f) a Source

to1 :: Rep1 (M1 i c f) a -> M1 i c f a Source

MonadPlus f => MonadPlus (M1 i c f)

Methods

mzero :: M1 i c f a Source

mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a Source

Alternative f => Alternative (M1 i c f)

Methods

empty :: M1 i c f a Source

(<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a Source

some :: M1 i c f a -> M1 i c f [a] Source

many :: M1 i c f a -> M1 i c f [a] Source

MonadZip f => MonadZip (M1 i c f)

Methods

mzip :: M1 i c f a -> M1 i c f b -> M1 i c f (a, b) Source

mzipWith :: (a -> b -> c) -> M1 i c f a -> M1 i c f b -> M1 i c f c Source

munzip :: M1 i c f (a, b) -> (M1 i c f a, M1 i c f b) Source

Eq (f p) => Eq (M1 i c f p)

Methods

(==) :: M1 i c f p -> M1 i c f p -> Bool Source

(/=) :: M1 i c f p -> M1 i c f p -> Bool Source

(Data p, Data (f p), Typeable Meta c, Typeable * i, Typeable (* -> *) f) => Data (M1 i c f p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> M1 i c f p -> c (M1 i c f p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (M1 i c f p) Source

toConstr :: M1 i c f p -> Constr Source

dataTypeOf :: M1 i c f p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (M1 i c f p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (M1 i c f p)) Source

gmapT :: (forall b. Data b => b -> b) -> M1 i c f p -> M1 i c f p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> M1 i c f p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 i c f p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) Source

Ord (f p) => Ord (M1 i c f p)

Methods

compare :: M1 i c f p -> M1 i c f p -> Ordering Source

(<) :: M1 i c f p -> M1 i c f p -> Bool Source

(<=) :: M1 i c f p -> M1 i c f p -> Bool Source

(>) :: M1 i c f p -> M1 i c f p -> Bool Source

(>=) :: M1 i c f p -> M1 i c f p -> Bool Source

max :: M1 i c f p -> M1 i c f p -> M1 i c f p Source

min :: M1 i c f p -> M1 i c f p -> M1 i c f p Source

Read (f p) => Read (M1 i c f p)

Methods

readsPrec :: Int -> ReadS (M1 i c f p) Source

readList :: ReadS [M1 i c f p] Source

readPrec :: ReadPrec (M1 i c f p) Source

readListPrec :: ReadPrec [M1 i c f p] Source

Show (f p) => Show (M1 i c f p)

Methods

showsPrec :: Int -> M1 i c f p -> ShowS Source

show :: M1 i c f p -> String Source

showList :: [M1 i c f p] -> ShowS Source

Generic (M1 i c f p)

Associated Types

type Rep (M1 i c f p) :: * -> * Source

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x Source

to :: Rep (M1 i c f p) x -> M1 i c f p Source

type Rep1 (M1 i c f)
type Rep1 (M1 i c f) = D1 (MetaData "M1" "GHC.Generics" "base" True) (C1 (MetaCons "M1" PrefixI True) (S1 (MetaSel (Just Symbol "unM1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)))
type Rep (M1 i c f p)
type Rep (M1 i c f p) = D1 (MetaData "M1" "GHC.Generics" "base" True) (C1 (MetaCons "M1" PrefixI True) (S1 (MetaSel (Just Symbol "unM1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f p))))

data (f :+: g) p infixr 5 Source

Sums: encode choice between constructors

Constructors

L1 (f p)
R1 (g p)

Instances

(Functor f, Functor g) => Functor ((:+:) f g)

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b Source

(<$) :: a -> (f :+: g) b -> (f :+: g) a Source

(Foldable f, Foldable g) => Foldable ((:+:) f g)

Methods

fold :: Monoid m => (f :+: g) m -> m Source

foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m Source

foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b Source

foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b Source

foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b Source

foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b Source

foldr1 :: (a -> a -> a) -> (f :+: g) a -> a Source

foldl1 :: (a -> a -> a) -> (f :+: g) a -> a Source

toList :: (f :+: g) a -> [a] Source

null :: (f :+: g) a -> Bool Source

length :: (f :+: g) a -> Int Source

elem :: Eq a => a -> (f :+: g) a -> Bool Source

maximum :: Ord a => (f :+: g) a -> a Source

minimum :: Ord a => (f :+: g) a -> a Source

sum :: Num a => (f :+: g) a -> a Source

product :: Num a => (f :+: g) a -> a Source

(Traversable f, Traversable g) => Traversable ((:+:) f g)

Methods

traverse :: Applicative f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b) Source

sequenceA :: Applicative f => (f :+: g) (f a) -> f ((f :+: g) a) Source

mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) Source

sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) Source

Generic1 ((:+:) f g)

Associated Types

type Rep1 ((:+:) f g :: * -> *) :: * -> * Source

Methods

from1 :: (f :+: g) a -> Rep1 (f :+: g) a Source

to1 :: Rep1 (f :+: g) a -> (f :+: g) a Source

(Eq (f p), Eq (g p)) => Eq ((:+:) f g p)

Methods

(==) :: (f :+: g) p -> (f :+: g) p -> Bool Source

(/=) :: (f :+: g) p -> (f :+: g) p -> Bool Source

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f p), Data (g p)) => Data ((:+:) f g p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (f :+: g) p -> c ((f :+: g) p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :+: g) p) Source

toConstr :: (f :+: g) p -> Constr Source

dataTypeOf :: (f :+: g) p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((f :+: g) p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :+: g) p)) Source

gmapT :: (forall b. Data b => b -> b) -> (f :+: g) p -> (f :+: g) p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> (f :+: g) p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :+: g) p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) Source

(Ord (f p), Ord (g p)) => Ord ((:+:) f g p)

Methods

compare :: (f :+: g) p -> (f :+: g) p -> Ordering Source

(<) :: (f :+: g) p -> (f :+: g) p -> Bool Source

(<=) :: (f :+: g) p -> (f :+: g) p -> Bool Source

(>) :: (f :+: g) p -> (f :+: g) p -> Bool Source

(>=) :: (f :+: g) p -> (f :+: g) p -> Bool Source

max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source

min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source

(Read (f p), Read (g p)) => Read ((:+:) f g p)

Methods

readsPrec :: Int -> ReadS ((f :+: g) p) Source

readList :: ReadS [(f :+: g) p] Source

readPrec :: ReadPrec ((f :+: g) p) Source

readListPrec :: ReadPrec [(f :+: g) p] Source

(Show (f p), Show (g p)) => Show ((:+:) f g p)

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS Source

show :: (f :+: g) p -> String Source

showList :: [(f :+: g) p] -> ShowS Source

Generic ((:+:) f g p)

Associated Types

type Rep ((:+:) f g p) :: * -> * Source

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x Source

to :: Rep ((f :+: g) p) x -> (f :+: g) p Source

type Rep1 ((:+:) f g)
type Rep ((:+:) f g p)

data (f :*: g) p infixr 6 Source

Products: encode multiple arguments to constructors

Constructors

(f p) :*: (g p) infixr 6

Instances

(Monad f, Monad g) => Monad ((:*:) f g)

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b Source

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b Source

return :: a -> (f :*: g) a Source

fail :: String -> (f :*: g) a Source

(Functor f, Functor g) => Functor ((:*:) f g)

Methods

fmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b Source

(<$) :: a -> (f :*: g) b -> (f :*: g) a Source

(MonadFix f, MonadFix g) => MonadFix ((:*:) f g)

Methods

mfix :: (a -> (f :*: g) a) -> (f :*: g) a Source

(Applicative f, Applicative g) => Applicative ((:*:) f g)

Methods

pure :: a -> (f :*: g) a Source

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b Source

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b Source

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a Source

(Foldable f, Foldable g) => Foldable ((:*:) f g)

Methods

fold :: Monoid m => (f :*: g) m -> m Source

foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m Source

foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b Source

foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b Source

foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b Source

foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b Source

foldr1 :: (a -> a -> a) -> (f :*: g) a -> a Source

foldl1 :: (a -> a -> a) -> (f :*: g) a -> a Source

toList :: (f :*: g) a -> [a] Source

null :: (f :*: g) a -> Bool Source

length :: (f :*: g) a -> Int Source

elem :: Eq a => a -> (f :*: g) a -> Bool Source

maximum :: Ord a => (f :*: g) a -> a Source

minimum :: Ord a => (f :*: g) a -> a Source

sum :: Num a => (f :*: g) a -> a Source

product :: Num a => (f :*: g) a -> a Source

(Traversable f, Traversable g) => Traversable ((:*:) f g)

Methods

traverse :: Applicative f => (a -> f b) -> (f :*: g) a -> f ((f :*: g) b) Source

sequenceA :: Applicative f => (f :*: g) (f a) -> f ((f :*: g) a) Source

mapM :: Monad m => (a -> m b) -> (f :*: g) a -> m ((f :*: g) b) Source

sequence :: Monad m => (f :*: g) (m a) -> m ((f :*: g) a) Source

Generic1 ((:*:) f g)

Associated Types

type Rep1 ((:*:) f g :: * -> *) :: * -> * Source

Methods

from1 :: (f :*: g) a -> Rep1 (f :*: g) a Source

to1 :: Rep1 (f :*: g) a -> (f :*: g) a Source

(MonadPlus f, MonadPlus g) => MonadPlus ((:*:) f g)

Methods

mzero :: (f :*: g) a Source

mplus :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a Source

(Alternative f, Alternative g) => Alternative ((:*:) f g)

Methods

empty :: (f :*: g) a Source

(<|>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a Source

some :: (f :*: g) a -> (f :*: g) [a] Source

many :: (f :*: g) a -> (f :*: g) [a] Source

(MonadZip f, MonadZip g) => MonadZip ((:*:) f g)

Methods

mzip :: (f :*: g) a -> (f :*: g) b -> (f :*: g) (a, b) Source

mzipWith :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c Source

munzip :: (f :*: g) (a, b) -> ((f :*: g) a, (f :*: g) b) Source

(Eq (f p), Eq (g p)) => Eq ((:*:) f g p)

Methods

(==) :: (f :*: g) p -> (f :*: g) p -> Bool Source

(/=) :: (f :*: g) p -> (f :*: g) p -> Bool Source

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f p), Data (g p)) => Data ((:*:) f g p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (f :*: g) p -> c ((f :*: g) p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :*: g) p) Source

toConstr :: (f :*: g) p -> Constr Source

dataTypeOf :: (f :*: g) p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((f :*: g) p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :*: g) p)) Source

gmapT :: (forall b. Data b => b -> b) -> (f :*: g) p -> (f :*: g) p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> (f :*: g) p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :*: g) p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) Source

(Ord (f p), Ord (g p)) => Ord ((:*:) f g p)

Methods

compare :: (f :*: g) p -> (f :*: g) p -> Ordering Source

(<) :: (f :*: g) p -> (f :*: g) p -> Bool Source

(<=) :: (f :*: g) p -> (f :*: g) p -> Bool Source

(>) :: (f :*: g) p -> (f :*: g) p -> Bool Source

(>=) :: (f :*: g) p -> (f :*: g) p -> Bool Source

max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p Source

min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p Source

(Read (f p), Read (g p)) => Read ((:*:) f g p)

Methods

readsPrec :: Int -> ReadS ((f :*: g) p) Source

readList :: ReadS [(f :*: g) p] Source

readPrec :: ReadPrec ((f :*: g) p) Source

readListPrec :: ReadPrec [(f :*: g) p] Source

(Show (f p), Show (g p)) => Show ((:*:) f g p)

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS Source

show :: (f :*: g) p -> String Source

showList :: [(f :*: g) p] -> ShowS Source

Generic ((:*:) f g p)

Associated Types

type Rep ((:*:) f g p) :: * -> * Source

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x Source

to :: Rep ((f :*: g) p) x -> (f :*: g) p Source

type Rep1 ((:*:) f g)
type Rep ((:*:) f g p)

newtype (f :.: g) p infixr 7 Source

Composition of functors

Constructors

Comp1

Fields

Instances

(Functor f, Functor g) => Functor ((:.:) f g)

Methods

fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b Source

(<$) :: a -> (f :.: g) b -> (f :.: g) a Source

(Applicative f, Applicative g) => Applicative ((:.:) f g)

Methods

pure :: a -> (f :.: g) a Source

(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source

(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source

(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source

(Foldable f, Foldable g) => Foldable ((:.:) f g)

Methods

fold :: Monoid m => (f :.: g) m -> m Source

foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m Source

foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b Source

foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b Source

foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b Source

foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b Source

foldr1 :: (a -> a -> a) -> (f :.: g) a -> a Source

foldl1 :: (a -> a -> a) -> (f :.: g) a -> a Source

toList :: (f :.: g) a -> [a] Source

null :: (f :.: g) a -> Bool Source

length :: (f :.: g) a -> Int Source

elem :: Eq a => a -> (f :.: g) a -> Bool Source

maximum :: Ord a => (f :.: g) a -> a Source

minimum :: Ord a => (f :.: g) a -> a Source

sum :: Num a => (f :.: g) a -> a Source

product :: Num a => (f :.: g) a -> a Source

(Traversable f, Traversable g) => Traversable ((:.:) f g)

Methods

traverse :: Applicative f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b) Source

sequenceA :: Applicative f => (f :.: g) (f a) -> f ((f :.: g) a) Source

mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) Source

sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) Source

Functor f => Generic1 ((:.:) f g)

Associated Types

type Rep1 ((:.:) f g :: * -> *) :: * -> * Source

Methods

from1 :: (f :.: g) a -> Rep1 (f :.: g) a Source

to1 :: Rep1 (f :.: g) a -> (f :.: g) a Source

(Alternative f, Applicative g) => Alternative ((:.:) f g)

Methods

empty :: (f :.: g) a Source

(<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a Source

some :: (f :.: g) a -> (f :.: g) [a] Source

many :: (f :.: g) a -> (f :.: g) [a] Source

Eq (f (g p)) => Eq ((:.:) f g p)

Methods

(==) :: (f :.: g) p -> (f :.: g) p -> Bool Source

(/=) :: (f :.: g) p -> (f :.: g) p -> Bool Source

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f (g p))) => Data ((:.:) f g p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (f :.: g) p -> c ((f :.: g) p) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :.: g) p) Source

toConstr :: (f :.: g) p -> Constr Source

dataTypeOf :: (f :.: g) p -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((f :.: g) p)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :.: g) p)) Source

gmapT :: (forall b. Data b => b -> b) -> (f :.: g) p -> (f :.: g) p Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r Source

gmapQ :: (forall d. Data d => d -> u) -> (f :.: g) p -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :.: g) p -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) Source

Ord (f (g p)) => Ord ((:.:) f g p)

Methods

compare :: (f :.: g) p -> (f :.: g) p -> Ordering Source

(<) :: (f :.: g) p -> (f :.: g) p -> Bool Source

(<=) :: (f :.: g) p -> (f :.: g) p -> Bool Source

(>) :: (f :.: g) p -> (f :.: g) p -> Bool Source

(>=) :: (f :.: g) p -> (f :.: g) p -> Bool Source

max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source

min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source

Read (f (g p)) => Read ((:.:) f g p)

Methods

readsPrec :: Int -> ReadS ((f :.: g) p) Source

readList :: ReadS [(f :.: g) p] Source

readPrec :: ReadPrec ((f :.: g) p) Source

readListPrec :: ReadPrec [(f :.: g) p] Source

Show (f (g p)) => Show ((:.:) f g p)

Methods

showsPrec :: Int -> (f :.: g) p -> ShowS Source

show :: (f :.: g) p -> String Source

showList :: [(f :.: g) p] -> ShowS Source

Generic ((:.:) f g p)

Associated Types

type Rep ((:.:) f g p) :: * -> * Source

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x Source

to :: Rep ((f :.: g) p) x -> (f :.: g) p Source

type Rep1 ((:.:) f g)
type Rep1 ((:.:) f g) = D1 (MetaData ":.:" "GHC.Generics" "base" True) (C1 (MetaCons "Comp1" PrefixI True) (S1 (MetaSel (Just Symbol "unComp1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) f (Rec1 g))))
type Rep ((:.:) f g p)
type Rep ((:.:) f g p) = D1 (MetaData ":.:" "GHC.Generics" "base" True) (C1 (MetaCons "Comp1" PrefixI True) (S1 (MetaSel (Just Symbol "unComp1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f (g p)))))

Unboxed representation types

data family URec (a :: *) (p :: *) Source

Constants of kind #

Instances

Functor (URec Char)

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b Source

(<$) :: a -> URec Char b -> URec Char a Source

Functor (URec Double)

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b Source

(<$) :: a -> URec Double b -> URec Double a Source

Functor (URec Float)

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b Source

(<$) :: a -> URec Float b -> URec Float a Source

Functor (URec Int)

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b Source

(<$) :: a -> URec Int b -> URec Int a Source

Functor (URec Word)

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b Source

(<$) :: a -> URec Word b -> URec Word a Source

Functor (URec (Ptr ()))

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source

Foldable (URec Char)

Methods

fold :: Monoid m => URec Char m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Char a -> m Source

foldr :: (a -> b -> b) -> b -> URec Char a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Char a -> b Source

foldl :: (b -> a -> b) -> b -> URec Char a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Char a -> b Source

foldr1 :: (a -> a -> a) -> URec Char a -> a Source

foldl1 :: (a -> a -> a) -> URec Char a -> a Source

toList :: URec Char a -> [a] Source

null :: URec Char a -> Bool Source

length :: URec Char a -> Int Source

elem :: Eq a => a -> URec Char a -> Bool Source

maximum :: Ord a => URec Char a -> a Source

minimum :: Ord a => URec Char a -> a Source

sum :: Num a => URec Char a -> a Source

product :: Num a => URec Char a -> a Source

Foldable (URec Double)

Methods

fold :: Monoid m => URec Double m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Double a -> m Source

foldr :: (a -> b -> b) -> b -> URec Double a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Double a -> b Source

foldl :: (b -> a -> b) -> b -> URec Double a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Double a -> b Source

foldr1 :: (a -> a -> a) -> URec Double a -> a Source

foldl1 :: (a -> a -> a) -> URec Double a -> a Source

toList :: URec Double a -> [a] Source

null :: URec Double a -> Bool Source

length :: URec Double a -> Int Source

elem :: Eq a => a -> URec Double a -> Bool Source

maximum :: Ord a => URec Double a -> a Source

minimum :: Ord a => URec Double a -> a Source

sum :: Num a => URec Double a -> a Source

product :: Num a => URec Double a -> a Source

Foldable (URec Float)

Methods

fold :: Monoid m => URec Float m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Float a -> m Source

foldr :: (a -> b -> b) -> b -> URec Float a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Float a -> b Source

foldl :: (b -> a -> b) -> b -> URec Float a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Float a -> b Source

foldr1 :: (a -> a -> a) -> URec Float a -> a Source

foldl1 :: (a -> a -> a) -> URec Float a -> a Source

toList :: URec Float a -> [a] Source

null :: URec Float a -> Bool Source

length :: URec Float a -> Int Source

elem :: Eq a => a -> URec Float a -> Bool Source

maximum :: Ord a => URec Float a -> a Source

minimum :: Ord a => URec Float a -> a Source

sum :: Num a => URec Float a -> a Source

product :: Num a => URec Float a -> a Source

Foldable (URec Int)

Methods

fold :: Monoid m => URec Int m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Int a -> m Source

foldr :: (a -> b -> b) -> b -> URec Int a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Int a -> b Source

foldl :: (b -> a -> b) -> b -> URec Int a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Int a -> b Source

foldr1 :: (a -> a -> a) -> URec Int a -> a Source

foldl1 :: (a -> a -> a) -> URec Int a -> a Source

toList :: URec Int a -> [a] Source

null :: URec Int a -> Bool Source

length :: URec Int a -> Int Source

elem :: Eq a => a -> URec Int a -> Bool Source

maximum :: Ord a => URec Int a -> a Source

minimum :: Ord a => URec Int a -> a Source

sum :: Num a => URec Int a -> a Source

product :: Num a => URec Int a -> a Source

Foldable (URec Word)

Methods

fold :: Monoid m => URec Word m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Word a -> m Source

foldr :: (a -> b -> b) -> b -> URec Word a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Word a -> b Source

foldl :: (b -> a -> b) -> b -> URec Word a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Word a -> b Source

foldr1 :: (a -> a -> a) -> URec Word a -> a Source

foldl1 :: (a -> a -> a) -> URec Word a -> a Source

toList :: URec Word a -> [a] Source

null :: URec Word a -> Bool Source

length :: URec Word a -> Int Source

elem :: Eq a => a -> URec Word a -> Bool Source

maximum :: Ord a => URec Word a -> a Source

minimum :: Ord a => URec Word a -> a Source

sum :: Num a => URec Word a -> a Source

product :: Num a => URec Word a -> a Source

Foldable (URec (Ptr ()))

Methods

fold :: Monoid m => URec (Ptr ()) m -> m Source

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m Source

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source

toList :: URec (Ptr ()) a -> [a] Source

null :: URec (Ptr ()) a -> Bool Source

length :: URec (Ptr ()) a -> Int Source

elem :: Eq a => a -> URec (Ptr ()) a -> Bool Source

maximum :: Ord a => URec (Ptr ()) a -> a Source

minimum :: Ord a => URec (Ptr ()) a -> a Source

sum :: Num a => URec (Ptr ()) a -> a Source

product :: Num a => URec (Ptr ()) a -> a Source

Traversable (URec Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) Source

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) Source

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) Source

sequence :: Monad m => URec Char (m a) -> m (URec Char a) Source

Traversable (URec Double)

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) Source

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) Source

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) Source

sequence :: Monad m => URec Double (m a) -> m (URec Double a) Source

Traversable (URec Float)

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) Source

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) Source

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) Source

sequence :: Monad m => URec Float (m a) -> m (URec Float a) Source

Traversable (URec Int)

Methods

traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) Source

sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) Source

mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) Source

sequence :: Monad m => URec Int (m a) -> m (URec Int a) Source

Traversable (URec Word)

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) Source

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) Source

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) Source

sequence :: Monad m => URec Word (m a) -> m (URec Word a) Source

Traversable (URec (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) Source

sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) Source

mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) Source

sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) Source

Generic1 (URec Char)

Associated Types

type Rep1 (URec Char :: * -> *) :: * -> * Source

Methods

from1 :: URec Char a -> Rep1 (URec Char) a Source

to1 :: Rep1 (URec Char) a -> URec Char a Source

Generic1 (URec Double)

Associated Types

type Rep1 (URec Double :: * -> *) :: * -> * Source

Methods

from1 :: URec Double a -> Rep1 (URec Double) a Source

to1 :: Rep1 (URec Double) a -> URec Double a Source

Generic1 (URec Float)

Associated Types

type Rep1 (URec Float :: * -> *) :: * -> * Source

Methods

from1 :: URec Float a -> Rep1 (URec Float) a Source

to1 :: Rep1 (URec Float) a -> URec Float a Source

Generic1 (URec Int)

Associated Types

type Rep1 (URec Int :: * -> *) :: * -> * Source

Methods

from1 :: URec Int a -> Rep1 (URec Int) a Source

to1 :: Rep1 (URec Int) a -> URec Int a Source

Generic1 (URec Word)

Associated Types

type Rep1 (URec Word :: * -> *) :: * -> * Source

Methods

from1 :: URec Word a -> Rep1 (URec Word) a Source

to1 :: Rep1 (URec Word) a -> URec Word a Source

Generic1 (URec (Ptr ()))

Associated Types

type Rep1 (URec (Ptr ()) :: * -> *) :: * -> * Source

Methods

from1 :: URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source

to1 :: Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source

Eq (URec Char p)

Methods

(==) :: URec Char p -> URec Char p -> Bool Source

(/=) :: URec Char p -> URec Char p -> Bool Source

Eq (URec Double p)

Methods

(==) :: URec Double p -> URec Double p -> Bool Source

(/=) :: URec Double p -> URec Double p -> Bool Source

Eq (URec Float p)

Methods

(==) :: URec Float p -> URec Float p -> Bool Source

(/=) :: URec Float p -> URec Float p -> Bool Source

Eq (URec Int p)

Methods

(==) :: URec Int p -> URec Int p -> Bool Source

(/=) :: URec Int p -> URec Int p -> Bool Source

Eq (URec Word p)

Methods

(==) :: URec Word p -> URec Word p -> Bool Source

(/=) :: URec Word p -> URec Word p -> Bool Source

Eq (URec (Ptr ()) p)

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

Ord (URec Char p)

Methods

compare :: URec Char p -> URec Char p -> Ordering Source

(<) :: URec Char p -> URec Char p -> Bool Source

(<=) :: URec Char p -> URec Char p -> Bool Source

(>) :: URec Char p -> URec Char p -> Bool Source

(>=) :: URec Char p -> URec Char p -> Bool Source

max :: URec Char p -> URec Char p -> URec Char p Source

min :: URec Char p -> URec Char p -> URec Char p Source

Ord (URec Double p)
Ord (URec Float p)
Ord (URec Int p)

Methods

compare :: URec Int p -> URec Int p -> Ordering Source

(<) :: URec Int p -> URec Int p -> Bool Source

(<=) :: URec Int p -> URec Int p -> Bool Source

(>) :: URec Int p -> URec Int p -> Bool Source

(>=) :: URec Int p -> URec Int p -> Bool Source

max :: URec Int p -> URec Int p -> URec Int p Source

min :: URec Int p -> URec Int p -> URec Int p Source

Ord (URec Word p)

Methods

compare :: URec Word p -> URec Word p -> Ordering Source

(<) :: URec Word p -> URec Word p -> Bool Source

(<=) :: URec Word p -> URec Word p -> Bool Source

(>) :: URec Word p -> URec Word p -> Bool Source

(>=) :: URec Word p -> URec Word p -> Bool Source

max :: URec Word p -> URec Word p -> URec Word p Source

min :: URec Word p -> URec Word p -> URec Word p Source

Ord (URec (Ptr ()) p)

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source

Show (URec Char p)
Show (URec Double p)
Show (URec Float p)
Show (URec Int p)

Methods

showsPrec :: Int -> URec Int p -> ShowS Source

show :: URec Int p -> String Source

showList :: [URec Int p] -> ShowS Source

Show (URec Word p)
Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> * Source

Methods

from :: URec Char p -> Rep (URec Char p) x Source

to :: Rep (URec Char p) x -> URec Char p Source

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> * Source

Methods

from :: URec Double p -> Rep (URec Double p) x Source

to :: Rep (URec Double p) x -> URec Double p Source

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> * Source

Methods

from :: URec Float p -> Rep (URec Float p) x Source

to :: Rep (URec Float p) x -> URec Float p Source

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> * Source

Methods

from :: URec Int p -> Rep (URec Int p) x Source

to :: Rep (URec Int p) x -> URec Int p Source

Generic (URec Word p)

Associated Types

type Rep (URec Word p) :: * -> * Source

Methods

from :: URec Word p -> Rep (URec Word p) x Source

to :: Rep (URec Word p) x -> URec Word p Source

Generic (URec (Ptr ()) p)

Associated Types

type Rep (URec (Ptr ()) p) :: * -> * Source

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source

data URec Char

Used for marking occurrences of Char#
data URec Char = UChar {}
data URec Double

Used for marking occurrences of Double#
data URec Float

Used for marking occurrences of Float#
data URec Int

Used for marking occurrences of Int#
data URec Int = UInt {}
data URec Word

Used for marking occurrences of Word#
data URec Word = UWord {}
type Rep1 (URec Char)
type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))
type Rep1 (URec Double)
type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))
type Rep1 (URec Float)
type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))
type Rep1 (URec Int)
type Rep1 (URec Int) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))
type Rep1 (URec Word)
type Rep1 (URec Word) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))
type Rep1 (URec (Ptr ()))
type Rep1 (URec (Ptr ())) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UAddr))
data URec (Ptr ())

Used for marking occurrences of Addr#
data URec (Ptr ()) = UAddr {}
type Rep (URec Char p)
type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))
type Rep (URec Double p)
type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))
type Rep (URec Float p)
type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))
type Rep (URec Int p)
type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))
type Rep (URec Word p)
type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UWord))
type Rep (URec (Ptr ()) p)
type Rep (URec (Ptr ()) p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UAddr))

type UAddr = URec (Ptr ()) Source

Type synonym for URec: Addr#

type UChar = URec Char Source

Type synonym for URec: Char#

type UDouble = URec Double Source

Type synonym for URec: Double#

type UFloat = URec Float Source

Type synonym for URec: Float#

type UInt = URec Int Source

Type synonym for URec: Int#

type UWord = URec Word Source

Type synonym for URec: Word#

Synonyms for convenience

type Rec0 = K1 R Source

Type synonym for encoding recursion (of kind *)

data R Source

Tag for K1: recursion (of kind *)

type D1 = M1 D Source

Type synonym for encoding meta-information for datatypes

type C1 = M1 C Source

Type synonym for encoding meta-information for constructors

type S1 = M1 S Source

Type synonym for encoding meta-information for record selectors

data D Source

Tag for M1: datatype

data C Source

Tag for M1: constructor

data S Source

Tag for M1: record selector

Meta-information

class Datatype d where Source

Class for datatypes that represent datatypes

Minimal complete definition

datatypeName, moduleName, packageName

Methods

datatypeName :: t d (f :: * -> *) a -> [Char] Source

The name of the datatype (unqualified)

moduleName :: t d (f :: * -> *) a -> [Char] Source

The fully-qualified name of the module where the type is declared

packageName :: t d (f :: * -> *) a -> [Char] Source

The package name of the module where the type is declared

isNewtype :: t d (f :: * -> *) a -> Bool Source

Marks if the datatype is actually a newtype

Instances

(KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI Bool nt) => Datatype Meta (MetaData n m p nt)

Methods

datatypeName :: t d f a -> [Char] Source

moduleName :: t d f a -> [Char] Source

packageName :: t d f a -> [Char] Source

isNewtype :: t d f a -> Bool Source

class Constructor c where Source

Class for datatypes that represent data constructors

Minimal complete definition

conName

Methods

conName :: t c (f :: * -> *) a -> [Char] Source

The name of the constructor

conFixity :: t c (f :: * -> *) a -> Fixity Source

The fixity of the constructor

conIsRecord :: t c (f :: * -> *) a -> Bool Source

Marks if this constructor is a record

Instances

(KnownSymbol n, SingI FixityI f, SingI Bool r) => Constructor Meta (MetaCons n f r)

Methods

conName :: t c f a -> [Char] Source

conFixity :: t c f a -> Fixity Source

conIsRecord :: t c f a -> Bool Source

class Selector s where Source

Class for datatypes that represent records

Minimal complete definition

selName, selSourceUnpackedness, selSourceStrictness, selDecidedStrictness

Methods

selName :: t s (f :: * -> *) a -> [Char] Source

The name of the selector

selSourceUnpackedness :: t s (f :: * -> *) a -> SourceUnpackedness Source

The selector's unpackedness annotation (if any)

selSourceStrictness :: t s (f :: * -> *) a -> SourceStrictness Source

The selector's strictness annotation (if any)

selDecidedStrictness :: t s (f :: * -> *) a -> DecidedStrictness Source

The strictness that the compiler inferred for the selector

Instances

data Fixity Source

Datatype to represent the fixity of a constructor. An infix | declaration directly corresponds to an application of Infix.

Constructors

Prefix
Infix Associativity Int

Instances

Eq Fixity

Methods

(==) :: Fixity -> Fixity -> Bool Source

(/=) :: Fixity -> Fixity -> Bool Source

Data Fixity

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity Source

toConstr :: Fixity -> Constr Source

dataTypeOf :: Fixity -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) Source

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source

Ord Fixity
Read Fixity
Show Fixity
Generic Fixity

Associated Types

type Rep Fixity :: * -> * Source

Methods

from :: Fixity -> Rep Fixity x Source

to :: Rep Fixity x -> Fixity Source

type Rep Fixity

data FixityI Source

This variant of Fixity appears at the type level.

Constructors

PrefixI
InfixI Associativity Nat

data Associativity Source

Datatype to represent the associativity of a constructor

Constructors

LeftAssociative
RightAssociative
NotAssociative

Instances

Bounded Associativity
Enum Associativity
Eq Associativity
Data Associativity

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Associativity Source

toConstr :: Associativity -> Constr Source

dataTypeOf :: Associativity -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Associativity) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Associativity) Source

gmapT :: (forall b. Data b => b -> b) -> Associativity -> Associativity Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Associativity -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Associativity -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity Source

Ord Associativity
Read Associativity
Show Associativity
Ix Associativity
Generic Associativity

Associated Types

type Rep Associativity :: * -> * Source

Methods

from :: Associativity -> Rep Associativity x Source

to :: Rep Associativity x -> Associativity Source

type Rep Associativity
type Rep Associativity = D1 (MetaData "Associativity" "GHC.Generics" "base" False) ((:+:) (C1 (MetaCons "LeftAssociative" PrefixI False) U1) ((:+:) (C1 (MetaCons "RightAssociative" PrefixI False) U1) (C1 (MetaCons "NotAssociative" PrefixI False) U1)))

prec :: Fixity -> Int Source

Get the precedence of a fixity value.

data SourceUnpackedness Source

The unpackedness of a field as the user wrote it in the source code. For example, in the following data type:

data E = ExampleConstructor     Int
           {-# NOUNPACK #-} Int
           {-#   UNPACK #-} Int

The fields of ExampleConstructor have NoSourceUnpackedness, SourceNoUnpack, and SourceUnpack, respectively.

Constructors

NoSourceUnpackedness
SourceNoUnpack
SourceUnpack

Instances

Bounded SourceUnpackedness
Enum SourceUnpackedness
Eq SourceUnpackedness
Data SourceUnpackedness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness Source

toConstr :: SourceUnpackedness -> Constr Source

dataTypeOf :: SourceUnpackedness -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) Source

gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r Source

gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness Source

Ord SourceUnpackedness
Read SourceUnpackedness
Show SourceUnpackedness
Ix SourceUnpackedness
Generic SourceUnpackedness
type Rep SourceUnpackedness
type Rep SourceUnpackedness = D1 (MetaData "SourceUnpackedness" "GHC.Generics" "base" False) ((:+:) (C1 (MetaCons "NoSourceUnpackedness" PrefixI False) U1) ((:+:) (C1 (MetaCons "SourceNoUnpack" PrefixI False) U1) (C1 (MetaCons "SourceUnpack" PrefixI False) U1)))

data SourceStrictness Source

The strictness of a field as the user wrote it in the source code. For example, in the following data type:

data E = ExampleConstructor Int ~Int !Int

The fields of ExampleConstructor have NoSourceStrictness, SourceLazy, and SourceStrict, respectively.

Constructors

NoSourceStrictness
SourceLazy
SourceStrict

Instances

Bounded SourceStrictness
Enum SourceStrictness
Eq SourceStrictness
Data SourceStrictness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness Source

toConstr :: SourceStrictness -> Constr Source

dataTypeOf :: SourceStrictness -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) Source

gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r Source

gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness Source

Ord SourceStrictness
Read SourceStrictness
Show SourceStrictness
Ix SourceStrictness
Generic SourceStrictness
type Rep SourceStrictness
type Rep SourceStrictness = D1 (MetaData "SourceStrictness" "GHC.Generics" "base" False) ((:+:) (C1 (MetaCons "NoSourceStrictness" PrefixI False) U1) ((:+:) (C1 (MetaCons "SourceLazy" PrefixI False) U1) (C1 (MetaCons "SourceStrict" PrefixI False) U1)))

data DecidedStrictness Source

The strictness that GHC infers for a field during compilation. Whereas there are nine different combinations of SourceUnpackedness and SourceStrictness, the strictness that GHC decides will ultimately be one of lazy, strict, or unpacked. What GHC decides is affected both by what the user writes in the source code and by GHC flags. As an example, consider this data type:

data E = ExampleConstructor {-# UNPACK #-} !Int !Int Int

Constructors

DecidedLazy
DecidedStrict
DecidedUnpack

Instances

Bounded DecidedStrictness
Enum DecidedStrictness
Eq DecidedStrictness
Data DecidedStrictness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness Source

toConstr :: DecidedStrictness -> Constr Source

dataTypeOf :: DecidedStrictness -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) Source

gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r Source

gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness Source

Ord DecidedStrictness
Read DecidedStrictness
Show DecidedStrictness
Ix DecidedStrictness
Generic DecidedStrictness
type Rep DecidedStrictness
type Rep DecidedStrictness = D1 (MetaData "DecidedStrictness" "GHC.Generics" "base" False) ((:+:) (C1 (MetaCons "DecidedLazy" PrefixI False) U1) ((:+:) (C1 (MetaCons "DecidedStrict" PrefixI False) U1) (C1 (MetaCons "DecidedUnpack" PrefixI False) U1)))

data Meta Source

Datatype to represent metadata associated with a datatype (MetaData), constructor (MetaCons), or field selector (MetaSel).

  • In MetaData n m p nt, n is the datatype's name, m is the module in which the datatype is defined, p is the package in which the datatype is defined, and nt is 'True if the datatype is a newtype.
  • In MetaCons n f s, n is the constructor's name, f is its fixity, and s is 'True if the constructor contains record selectors.
  • In MetaSel mn su ss ds, if the field is uses record syntax, then mn is Just the record name. Otherwise, mn is 'Nothing. su and ss are the field's unpackedness and strictness annotations, and ds is the strictness that GHC infers for the field.

Constructors

MetaData Symbol Symbol Symbol Bool
MetaCons Symbol FixityI Bool
MetaSel (Maybe Symbol) SourceUnpackedness SourceStrictness DecidedStrictness

Instances

(KnownSymbol n, SingI FixityI f, SingI Bool r) => Constructor Meta (MetaCons n f r)

Methods

conName :: t c f a -> [Char] Source

conFixity :: t c f a -> Fixity Source

conIsRecord :: t c f a -> Bool Source

(KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI Bool nt) => Datatype Meta (MetaData n m p nt)

Methods

datatypeName :: t d f a -> [Char] Source

moduleName :: t d f a -> [Char] Source

packageName :: t d f a -> [Char] Source

isNewtype :: t d f a -> Bool Source

(SingI (Maybe Symbol) mn, SingI SourceUnpackedness su, SingI SourceStrictness ss, SingI DecidedStrictness ds) => Selector Meta (MetaSel mn su ss ds)

Generic type classes

class Generic a where Source

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

Minimal complete definition

from, to

Associated Types

type Rep a :: * -> * Source

Generic representation type

Methods

from :: a -> Rep a x Source

Convert from the datatype to its representation

to :: Rep a x -> a Source

Convert from the representation to the datatype

Instances

Generic Bool

Associated Types

type Rep Bool :: * -> * Source

Methods

from :: Bool -> Rep Bool x Source

to :: Rep Bool x -> Bool Source

Generic Ordering

Associated Types

type Rep Ordering :: * -> * Source

Methods

from :: Ordering -> Rep Ordering x Source

to :: Rep Ordering x -> Ordering Source

Generic ()

Associated Types

type Rep () :: * -> * Source

Methods

from :: () -> Rep () x Source

to :: Rep () x -> () Source

Generic DecidedStrictness
Generic SourceStrictness
Generic SourceUnpackedness
Generic Associativity

Associated Types

type Rep Associativity :: * -> * Source

Methods

from :: Associativity -> Rep Associativity x Source

to :: Rep Associativity x -> Associativity Source

Generic Fixity

Associated Types

type Rep Fixity :: * -> * Source

Methods

from :: Fixity -> Rep Fixity x Source

to :: Rep Fixity x -> Fixity Source

Generic Any

Associated Types

type Rep Any :: * -> * Source

Methods

from :: Any -> Rep Any x Source

to :: Rep Any x -> Any Source

Generic All

Associated Types

type Rep All :: * -> * Source

Methods

from :: All -> Rep All x Source

to :: Rep All x -> All Source

Generic ExitCode

Associated Types

type Rep ExitCode :: * -> * Source

Methods

from :: ExitCode -> Rep ExitCode x Source

to :: Rep ExitCode x -> ExitCode Source

Generic Version

Associated Types

type Rep Version :: * -> * Source

Methods

from :: Version -> Rep Version x Source

to :: Rep Version x -> Version Source

Generic Void

Associated Types

type Rep Void :: * -> * Source

Methods

from :: Void -> Rep Void x Source

to :: Rep Void x -> Void Source

Generic [a]

Associated Types

type Rep [a] :: * -> * Source

Methods

from :: [a] -> Rep [a] x Source

to :: Rep [a] x -> [a] Source

Generic (Maybe a)

Associated Types

type Rep (Maybe a) :: * -> * Source

Methods

from :: Maybe a -> Rep (Maybe a) x Source

to :: Rep (Maybe a) x -> Maybe a Source

Generic (V1 p)

Associated Types

type Rep (V1 p) :: * -> * Source

Methods

from :: V1 p -> Rep (V1 p) x Source

to :: Rep (V1 p) x -> V1 p Source

Generic (U1 p)

Associated Types

type Rep (U1 p) :: * -> * Source

Methods

from :: U1 p -> Rep (U1 p) x Source

to :: Rep (U1 p) x -> U1 p Source

Generic (Par1 p)

Associated Types

type Rep (Par1 p) :: * -> * Source

Methods

from :: Par1 p -> Rep (Par1 p) x Source

to :: Rep (Par1 p) x -> Par1 p Source

Generic (Last a)

Associated Types

type Rep (Last a) :: * -> * Source

Methods

from :: Last a -> Rep (Last a) x Source

to :: Rep (Last a) x -> Last a Source

Generic (First a)

Associated Types

type Rep (First a) :: * -> * Source

Methods

from :: First a -> Rep (First a) x Source

to :: Rep (First a) x -> First a Source

Generic (Product a)

Associated Types

type Rep (Product a) :: * -> * Source

Methods

from :: Product a -> Rep (Product a) x Source

to :: Rep (Product a) x -> Product a Source

Generic (Sum a)

Associated Types

type Rep (Sum a) :: * -> * Source

Methods

from :: Sum a -> Rep (Sum a) x Source

to :: Rep (Sum a) x -> Sum a Source

Generic (Endo a)

Associated Types

type Rep (Endo a) :: * -> * Source

Methods

from :: Endo a -> Rep (Endo a) x Source

to :: Rep (Endo a) x -> Endo a Source

Generic (Dual a)

Associated Types

type Rep (Dual a) :: * -> * Source

Methods

from :: Dual a -> Rep (Dual a) x Source

to :: Rep (Dual a) x -> Dual a Source

Generic (ZipList a)

Associated Types

type Rep (ZipList a) :: * -> * Source

Methods

from :: ZipList a -> Rep (ZipList a) x Source

to :: Rep (ZipList a) x -> ZipList a Source

Generic (Complex a)

Associated Types

type Rep (Complex a) :: * -> * Source

Methods

from :: Complex a -> Rep (Complex a) x Source

to :: Rep (Complex a) x -> Complex a Source

Generic (NonEmpty a)

Associated Types

type Rep (NonEmpty a) :: * -> * Source

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x Source

to :: Rep (NonEmpty a) x -> NonEmpty a Source

Generic (Option a)

Associated Types

type Rep (Option a) :: * -> * Source

Methods

from :: Option a -> Rep (Option a) x Source

to :: Rep (Option a) x -> Option a Source

Generic (WrappedMonoid m)

Associated Types

type Rep (WrappedMonoid m) :: * -> * Source

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x Source

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m Source

Generic (Last a)

Associated Types

type Rep (Last a) :: * -> * Source

Methods

from :: Last a -> Rep (Last a) x Source

to :: Rep (Last a) x -> Last a Source

Generic (First a)

Associated Types

type Rep (First a) :: * -> * Source

Methods

from :: First a -> Rep (First a) x Source

to :: Rep (First a) x -> First a Source

Generic (Max a)

Associated Types

type Rep (Max a) :: * -> * Source

Methods

from :: Max a -> Rep (Max a) x Source

to :: Rep (Max a) x -> Max a Source

Generic (Min a)

Associated Types

type Rep (Min a) :: * -> * Source

Methods

from :: Min a -> Rep (Min a) x Source

to :: Rep (Min a) x -> Min a Source

Generic (Identity a)

Associated Types

type Rep (Identity a) :: * -> * Source

Methods

from :: Identity a -> Rep (Identity a) x Source

to :: Rep (Identity a) x -> Identity a Source

Generic (Either a b)

Associated Types

type Rep (Either a b) :: * -> * Source

Methods

from :: Either a b -> Rep (Either a b) x Source

to :: Rep (Either a b) x -> Either a b Source

Generic (Rec1 f p)

Associated Types

type Rep (Rec1 f p) :: * -> * Source

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x Source

to :: Rep (Rec1 f p) x -> Rec1 f p Source

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> * Source

Methods

from :: URec Char p -> Rep (URec Char p) x Source

to :: Rep (URec Char p) x -> URec Char p Source

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> * Source

Methods

from :: URec Double p -> Rep (URec Double p) x Source

to :: Rep (URec Double p) x -> URec Double p Source

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> * Source

Methods

from :: URec Float p -> Rep (URec Float p) x Source

to :: Rep (URec Float p) x -> URec Float p Source

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> * Source

Methods

from :: URec Int p -> Rep (URec Int p) x Source

to :: Rep (URec Int p) x -> URec Int p Source

Generic (URec Word p)

Associated Types

type Rep (URec Word p) :: * -> * Source

Methods

from :: URec Word p -> Rep (URec Word p) x Source

to :: Rep (URec Word p) x -> URec Word p Source

Generic (URec (Ptr ()) p)

Associated Types

type Rep (URec (Ptr ()) p) :: * -> * Source

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source

Generic (a, b)

Associated Types

type Rep (a, b) :: * -> * Source

Methods

from :: (a, b) -> Rep (a, b) x Source

to :: Rep (a, b) x -> (a, b) Source

Generic (Proxy k t)

Associated Types

type Rep (Proxy k t) :: * -> * Source

Methods

from :: Proxy k t -> Rep (Proxy k t) x Source

to :: Rep (Proxy k t) x -> Proxy k t Source

Generic (WrappedMonad m a)

Associated Types

type Rep (WrappedMonad m a) :: * -> * Source

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source

Generic (Arg a b)

Associated Types

type Rep (Arg a b) :: * -> * Source

Methods

from :: Arg a b -> Rep (Arg a b) x Source

to :: Rep (Arg a b) x -> Arg a b Source

Generic (K1 i c p)

Associated Types

type Rep (K1 i c p) :: * -> * Source

Methods

from :: K1 i c p -> Rep (K1 i c p) x Source

to :: Rep (K1 i c p) x -> K1 i c p Source

Generic ((:+:) f g p)

Associated Types

type Rep ((:+:) f g p) :: * -> * Source

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x Source

to :: Rep ((f :+: g) p) x -> (f :+: g) p Source

Generic ((:*:) f g p)

Associated Types

type Rep ((:*:) f g p) :: * -> * Source

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x Source

to :: Rep ((f :*: g) p) x -> (f :*: g) p Source

Generic ((:.:) f g p)

Associated Types

type Rep ((:.:) f g p) :: * -> * Source

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x Source

to :: Rep ((f :.: g) p) x -> (f :.: g) p Source

Generic (a, b, c)

Associated Types

type Rep (a, b, c) :: * -> * Source

Methods

from :: (a, b, c) -> Rep (a, b, c) x Source

to :: Rep (a, b, c) x -> (a, b, c) Source

Generic (Alt k f a)

Associated Types

type Rep (Alt k f a) :: * -> * Source

Methods

from :: Alt k f a -> Rep (Alt k f a) x Source

to :: Rep (Alt k f a) x -> Alt k f a Source

Generic (Const k a b)

Associated Types

type Rep (Const k a b) :: * -> * Source

Methods

from :: Const k a b -> Rep (Const k a b) x Source

to :: Rep (Const k a b) x -> Const k a b Source

Generic (WrappedArrow a b c)

Associated Types

type Rep (WrappedArrow a b c) :: * -> * Source

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source

Generic (M1 i c f p)

Associated Types

type Rep (M1 i c f p) :: * -> * Source

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x Source

to :: Rep (M1 i c f p) x -> M1 i c f p Source

Generic (a, b, c, d)

Associated Types

type Rep (a, b, c, d) :: * -> * Source

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x Source

to :: Rep (a, b, c, d) x -> (a, b, c, d) Source

Generic (Product k f g a)

Associated Types

type Rep (Product k f g a) :: * -> * Source

Methods

from :: Product k f g a -> Rep (Product k f g a) x Source

to :: Rep (Product k f g a) x -> Product k f g a Source

Generic (Sum k f g a)

Associated Types

type Rep (Sum k f g a) :: * -> * Source

Methods

from :: Sum k f g a -> Rep (Sum k f g a) x Source

to :: Rep (Sum k f g a) x -> Sum k f g a Source

Generic (a, b, c, d, e)

Associated Types

type Rep (a, b, c, d, e) :: * -> * Source

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x Source

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) Source

Generic (Compose k k1 f g a)

Associated Types

type Rep (Compose k k1 f g a) :: * -> * Source

Methods

from :: Compose k k1 f g a -> Rep (Compose k k1 f g a) x Source

to :: Rep (Compose k k1 f g a) x -> Compose k k1 f g a Source

Generic (a, b, c, d, e, f)

Associated Types

type Rep (a, b, c, d, e, f) :: * -> * Source

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x Source

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) Source

Generic (a, b, c, d, e, f, g)

Associated Types

type Rep (a, b, c, d, e, f, g) :: * -> * Source

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x Source

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) Source

class Generic1 f where Source

Representable types of kind * -> *. This class is derivable in GHC with the DeriveGeneric flag on.

Minimal complete definition

from1, to1

Associated Types

type Rep1 f :: * -> * Source

Generic representation type

Methods

from1 :: f a -> Rep1 f a Source

Convert from the datatype to its representation

to1 :: Rep1 f a -> f a Source

Convert from the representation to the datatype

Instances

Generic1 []

Associated Types

type Rep1 ([] :: * -> *) :: * -> * Source

Methods

from1 :: [a] -> Rep1 [] a Source

to1 :: Rep1 [] a -> [a] Source

Generic1 Maybe

Associated Types

type Rep1 (Maybe :: * -> *) :: * -> * Source

Methods

from1 :: Maybe a -> Rep1 Maybe a Source

to1 :: Rep1 Maybe a -> Maybe a Source

Generic1 V1

Associated Types

type Rep1 (V1 :: * -> *) :: * -> * Source

Methods

from1 :: V1 a -> Rep1 V1 a Source

to1 :: Rep1 V1 a -> V1 a Source

Generic1 U1

Associated Types

type Rep1 (U1 :: * -> *) :: * -> * Source

Methods

from1 :: U1 a -> Rep1 U1 a Source

to1 :: Rep1 U1 a -> U1 a Source

Generic1 Par1

Associated Types

type Rep1 (Par1 :: * -> *) :: * -> * Source

Methods

from1 :: Par1 a -> Rep1 Par1 a Source

to1 :: Rep1 Par1 a -> Par1 a Source

Generic1 Last

Associated Types

type Rep1 (Last :: * -> *) :: * -> * Source

Methods

from1 :: Last a -> Rep1 Last a Source

to1 :: Rep1 Last a -> Last a Source

Generic1 First

Associated Types

type Rep1 (First :: * -> *) :: * -> * Source

Methods

from1 :: First a -> Rep1 First a Source

to1 :: Rep1 First a -> First a Source

Generic1 Product

Associated Types

type Rep1 (Product :: * -> *) :: * -> * Source

Methods

from1 :: Product a -> Rep1 Product a Source

to1 :: Rep1 Product a -> Product a Source

Generic1 Sum

Associated Types

type Rep1 (Sum :: * -> *) :: * -> * Source

Methods

from1 :: Sum a -> Rep1 Sum a Source

to1 :: Rep1 Sum a -> Sum a Source

Generic1 Dual

Associated Types

type Rep1 (Dual :: * -> *) :: * -> * Source

Methods

from1 :: Dual a -> Rep1 Dual a Source

to1 :: Rep1 Dual a -> Dual a Source

Generic1 ZipList

Associated Types

type Rep1 (ZipList :: * -> *) :: * -> * Source

Methods

from1 :: ZipList a -> Rep1 ZipList a Source

to1 :: Rep1 ZipList a -> ZipList a Source

Generic1 Complex

Associated Types

type Rep1 (Complex :: * -> *) :: * -> * Source

Methods

from1 :: Complex a -> Rep1 Complex a Source

to1 :: Rep1 Complex a -> Complex a Source

Generic1 NonEmpty

Associated Types

type Rep1 (NonEmpty :: * -> *) :: * -> * Source

Methods

from1 :: NonEmpty a -> Rep1 NonEmpty a Source

to1 :: Rep1 NonEmpty a -> NonEmpty a Source

Generic1 Option

Associated Types

type Rep1 (Option :: * -> *) :: * -> * Source

Methods

from1 :: Option a -> Rep1 Option a Source

to1 :: Rep1 Option a -> Option a Source

Generic1 WrappedMonoid

Associated Types

type Rep1 (WrappedMonoid :: * -> *) :: * -> * Source

Methods

from1 :: WrappedMonoid a -> Rep1 WrappedMonoid a Source

to1 :: Rep1 WrappedMonoid a -> WrappedMonoid a Source

Generic1 Last

Associated Types

type Rep1 (Last :: * -> *) :: * -> * Source

Methods

from1 :: Last a -> Rep1 Last a Source

to1 :: Rep1 Last a -> Last a Source

Generic1 First

Associated Types

type Rep1 (First :: * -> *) :: * -> * Source

Methods

from1 :: First a -> Rep1 First a Source

to1 :: Rep1 First a -> First a Source

Generic1 Max

Associated Types

type Rep1 (Max :: * -> *) :: * -> * Source

Methods

from1 :: Max a -> Rep1 Max a Source

to1 :: Rep1 Max a -> Max a Source

Generic1 Min

Associated Types

type Rep1 (Min :: * -> *) :: * -> * Source

Methods

from1 :: Min a -> Rep1 Min a Source

to1 :: Rep1 Min a -> Min a Source

Generic1 Identity

Associated Types

type Rep1 (Identity :: * -> *) :: * -> * Source

Methods

from1 :: Identity a -> Rep1 Identity a Source

to1 :: Rep1 Identity a -> Identity a Source

Generic1 (Either a)

Associated Types

type Rep1 (Either a :: * -> *) :: * -> * Source

Methods

from1 :: Either a a -> Rep1 (Either a) a Source

to1 :: Rep1 (Either a) a -> Either a a Source

Generic1 (Rec1 f)

Associated Types

type Rep1 (Rec1 f :: * -> *) :: * -> * Source

Methods

from1 :: Rec1 f a -> Rep1 (Rec1 f) a Source

to1 :: Rep1 (Rec1 f) a -> Rec1 f a Source

Generic1 (URec Char)

Associated Types

type Rep1 (URec Char :: * -> *) :: * -> * Source

Methods

from1 :: URec Char a -> Rep1 (URec Char) a Source

to1 :: Rep1 (URec Char) a -> URec Char a Source

Generic1 (URec Double)

Associated Types

type Rep1 (URec Double :: * -> *) :: * -> * Source

Methods

from1 :: URec Double a -> Rep1 (URec Double) a Source

to1 :: Rep1 (URec Double) a -> URec Double a Source

Generic1 (URec Float)

Associated Types

type Rep1 (URec Float :: * -> *) :: * -> * Source

Methods

from1 :: URec Float a -> Rep1 (URec Float) a Source

to1 :: Rep1 (URec Float) a -> URec Float a Source

Generic1 (URec Int)

Associated Types

type Rep1 (URec Int :: * -> *) :: * -> * Source

Methods

from1 :: URec Int a -> Rep1 (URec Int) a Source

to1 :: Rep1 (URec Int) a -> URec Int a Source

Generic1 (URec Word)

Associated Types

type Rep1 (URec Word :: * -> *) :: * -> * Source

Methods

from1 :: URec Word a -> Rep1 (URec Word) a Source

to1 :: Rep1 (URec Word) a -> URec Word a Source

Generic1 (URec (Ptr ()))

Associated Types

type Rep1 (URec (Ptr ()) :: * -> *) :: * -> * Source

Methods

from1 :: URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source

to1 :: Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source

Generic1 ((,) a)

Associated Types

type Rep1 ((,) a :: * -> *) :: * -> * Source

Methods

from1 :: (a, a) -> Rep1 ((,) a) a Source

to1 :: Rep1 ((,) a) a -> (a, a) Source

Generic1 (Proxy *)

Associated Types

type Rep1 (Proxy * :: * -> *) :: * -> * Source

Methods

from1 :: Proxy * a -> Rep1 (Proxy *) a Source

to1 :: Rep1 (Proxy *) a -> Proxy * a Source

Generic1 (WrappedMonad m)

Associated Types

type Rep1 (WrappedMonad m :: * -> *) :: * -> * Source

Methods

from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a Source

to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a Source

Generic1 (Arg a)

Associated Types

type Rep1 (Arg a :: * -> *) :: * -> * Source

Methods

from1 :: Arg a a -> Rep1 (Arg a) a Source

to1 :: Rep1 (Arg a) a -> Arg a a Source

Generic1 (K1 i c)

Associated Types

type Rep1 (K1 i c :: * -> *) :: * -> * Source

Methods

from1 :: K1 i c a -> Rep1 (K1 i c) a Source

to1 :: Rep1 (K1 i c) a -> K1 i c a Source

Generic1 ((:+:) f g)

Associated Types

type Rep1 ((:+:) f g :: * -> *) :: * -> * Source

Methods

from1 :: (f :+: g) a -> Rep1 (f :+: g) a Source

to1 :: Rep1 (f :+: g) a -> (f :+: g) a Source

Generic1 ((:*:) f g)

Associated Types

type Rep1 ((:*:) f g :: * -> *) :: * -> * Source

Methods

from1 :: (f :*: g) a -> Rep1 (f :*: g) a Source

to1 :: Rep1 (f :*: g) a -> (f :*: g) a Source

Functor f => Generic1 ((:.:) f g)

Associated Types

type Rep1 ((:.:) f g :: * -> *) :: * -> * Source

Methods

from1 :: (f :.: g) a -> Rep1 (f :.: g) a Source

to1 :: Rep1 (f :.: g) a -> (f :.: g) a Source

Generic1 ((,,) a b)

Associated Types

type Rep1 ((,,) a b :: * -> *) :: * -> * Source

Methods

from1 :: (a, b, a) -> Rep1 ((,,) a b) a Source

to1 :: Rep1 ((,,) a b) a -> (a, b, a) Source

Generic1 (Alt * f)

Associated Types

type Rep1 (Alt * f :: * -> *) :: * -> * Source

Methods

from1 :: Alt * f a -> Rep1 (Alt * f) a Source

to1 :: Rep1 (Alt * f) a -> Alt * f a Source

Generic1 (Const * a)

Associated Types

type Rep1 (Const * a :: * -> *) :: * -> * Source

Methods

from1 :: Const * a a -> Rep1 (Const * a) a Source

to1 :: Rep1 (Const * a) a -> Const * a a Source

Generic1 (WrappedArrow a b)

Associated Types

type Rep1 (WrappedArrow a b :: * -> *) :: * -> * Source

Methods

from1 :: WrappedArrow a b a -> Rep1 (WrappedArrow a b) a Source

to1 :: Rep1 (WrappedArrow a b) a -> WrappedArrow a b a Source

Generic1 (M1 i c f)

Associated Types

type Rep1 (M1 i c f :: * -> *) :: * -> * Source

Methods

from1 :: M1 i c f a -> Rep1 (M1 i c f) a Source

to1 :: Rep1 (M1 i c f) a -> M1 i c f a Source

Generic1 ((,,,) a b c)

Associated Types

type Rep1 ((,,,) a b c :: * -> *) :: * -> * Source

Methods

from1 :: (a, b, c, a) -> Rep1 ((,,,) a b c) a Source

to1 :: Rep1 ((,,,) a b c) a -> (a, b, c, a) Source

Generic1 (Product * f g)

Associated Types

type Rep1 (Product * f g :: * -> *) :: * -> * Source

Methods

from1 :: Product * f g a -> Rep1 (Product * f g) a Source

to1 :: Rep1 (Product * f g) a -> Product * f g a Source

Generic1 (Sum * f g)

Associated Types

type Rep1 (Sum * f g :: * -> *) :: * -> * Source

Methods

from1 :: Sum * f g a -> Rep1 (Sum * f g) a Source

to1 :: Rep1 (Sum * f g) a -> Sum * f g a Source

Generic1 ((,,,,) a b c d)

Associated Types

type Rep1 ((,,,,) a b c d :: * -> *) :: * -> * Source

Methods

from1 :: (a, b, c, d, a) -> Rep1 ((,,,,) a b c d) a Source

to1 :: Rep1 ((,,,,) a b c d) a -> (a, b, c, d, a) Source

Functor f => Generic1 (Compose * * f g)

Associated Types

type Rep1 (Compose * * f g :: * -> *) :: * -> * Source

Methods

from1 :: Compose * * f g a -> Rep1 (Compose * * f g) a Source

to1 :: Rep1 (Compose * * f g) a -> Compose * * f g a Source

Generic1 ((,,,,,) a b c d e)

Associated Types

type Rep1 ((,,,,,) a b c d e :: * -> *) :: * -> * Source

Methods

from1 :: (a, b, c, d, e, a) -> Rep1 ((,,,,,) a b c d e) a Source

to1 :: Rep1 ((,,,,,) a b c d e) a -> (a, b, c, d, e, a) Source

Generic1 ((,,,,,,) a b c d e f)

Associated Types

type Rep1 ((,,,,,,) a b c d e f :: * -> *) :: * -> * Source

Methods

from1 :: (a, b, c, d, e, f, a) -> Rep1 ((,,,,,,) a b c d e f) a Source

to1 :: Rep1 ((,,,,,,) a b c d e f) a -> (a, b, c, d, e, f, a) Source

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.0.1/docs/html/libraries/base-4.9.0.0/GHC-Generics.html