Data.Generics.Aliases

Extend the identity function with a type-specific transformation. The function created by mkT ext behaves like the identity function on all arguments which cannot be cast to type b, and like the function ext otherwise. The name mkT is short for "make transformation".

Examples

>>> mkT not TrueFalse

>>> mkT not 'a''a'

Extend a generic transformation by a type-specific transformation. The function created by extT def ext behaves like the generic transformation def if its argument cannot be cast to the type b, and like the type-specific transformation ext otherwise. The name extT is short for "extend transformation".

Examples

>>> extT id not TrueFalse

>>> extT id not 'a''a'

The function created by mkQ def f returns the default result def if its argument cannot be cast to type b, otherwise it returns the result of applying f to its argument. The name mkQ is short for "make query".

Examples

>>> mkQ "default" (show :: Bool -> String) True"True"

>>> mkQ "default" (show :: Bool -> String) ()"default"

Extend a generic query by a type-specific query. The function created by extQ def ext behaves like the generic query def if its argument cannot be cast to the type b, and like the type-specific query ext otherwise. The name extQ is short for "extend query".

Examples

>>> extQ (const True) not TrueFalse

>>> extQ (const True) not 'a'True

Extend the default monadic action pure :: Monad m => a -> m a by a type-specific monadic action. The function created by mkM act behaves like pure if its argument cannot be cast to type b, and like the monadic action act otherwise. The name mkM is short for "make monadic transformation".

Examples

>>> mkM (\x -> [x, not x]) True[True,False]

>>> mkM (\x -> [x, not x]) (5 :: Int)[5]

Extend a generic monadic transformation by a type-specific case. The function created by extM def ext behaves like the monadic transformation def if its argument cannot be cast to type b, and like the monadic transformation ext otherwise. The name extM is short for "extend monadic transformation".

Examples

>>> extM (\x -> [x,x])(\x -> [not x, x]) True[False,True]

>>> extM (\x -> [x,x])(\x -> [not x, x]) (5 :: Int)[5,5]

Extend the default MonadPlus action const mzero by a type-specific MonadPlus action. The function created by mkMp act behaves like const mzero if its argument cannot be cast to type b, and like the monadic action act otherwise. The name mkMp is short for "make MonadPlus transformation".

Examples

>>> mkMp (\x -> Just (not x)) TrueJust False

>>> mkMp (\x -> Just (not x)) 'a'Nothing

Extend a generic MonadPlus transformation by a type-specific case. The function created by extMp def ext behaves like MonadPlus transformation def if its argument cannot be cast to type b, and like the transformation ext otherwise. Note that extMp behaves exactly like extM. The name extMp is short for "extend MonadPlus transformation".

Examples

>>> extMp (\x -> [x,x])(\x -> [not x, x]) True[False,True]

>>> extMp (\x -> [x,x])(\x -> [not x, x]) (5 :: Int)[5,5]

Make a generic reader from a type-specific case. The function created by mkR f behaves like the reader f if an expression of type a can be cast to type b, and like the expression mzero otherwise. The name mkR is short for "make reader".

Examples

>>> mkR (Just True) :: Maybe BoolJust True

>>> mkR (Just True) :: Maybe IntNothing

Extend a generic reader by a type-specific case. The reader created by extR def ext behaves like the reader def if expressions of type b cannot be cast to type a, and like the reader ext otherwise. The name extR is short for "extend reader".

Examples

>>> extR (Just True) (Just 'a')Just True

>>> extR (Just True) (Just False)Just False

Extend a generic builder by a type-specific case. The builder created by extB def ext returns def if ext cannot be cast to type a, and like ext otherwise. The name extB is short for "extend builder".

Examples

>>> extB True 'a'True

>>> extB True FalseFalse

Flexible type extension

Examples

>>> ext0 [1 :: Int, 2, 3] [True, False] :: [Int][1,2,3]

>>> ext0 [1 :: Int, 2, 3] [4 :: Int, 5, 6] :: [Int][4,5,6]

Generic transformations, i.e., take an "a" and return an "a"

The type synonym GenericT has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The newtype GenericT' wraps GenericT in a newtype to lift this restriction.

Generic queries of type "r", i.e., take any "a" and return an "r"

The type synonym GenericQ has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The newtype GenericQ' wraps GenericQ in a newtype to lift this restriction.

Generic monadic transformations, i.e., take an "a" and compute an "a"

The type synonym GenericM has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The newtype GenericM' wraps GenericM in a newtype to lift this restriction.

Generic readers, say monadic builders, i.e., produce an "a" with the help of a monad "m".

The type synonym GenericR has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The data type GenericR' wraps GenericR in a data type to lift this restriction.

Generic builders i.e., produce an "a".

The type synonym GenericB has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The data type GenericB' wraps GenericB in a data type to lift this restriction.

The general scheme underlying generic functions assumed by gfoldl; there are isomorphisms such as GenericT = Generic T.

The type synonym Generic has a polymorphic type, and can therefore not appear in places where monomorphic types are expected, for example in a list. The data type Generic' wraps Generic in a data type to lift this restriction.