Modulesyb-0.7.4

Generics.SYB.Aliases

Synopsis

value choiceMp
value choiceQ
value ext0
value ext1
value ext1B
value ext1M
value ext1Q
value ext1R
value ext1T
value ext2
value ext2B
value ext2M
value ext2Q
value ext2R
value ext2T
value extB
value extM
value extMp
value extQ
value extR
value extT
value mkM
value mkMp
value mkQ
value mkR
value mkT
value orElse
value recoverMp
value recoverQ
type Generic
newtype Generic'
type GenericB
newtype GenericB'
type GenericM
newtype GenericM'
type GenericQ
newtype GenericQ'
type GenericR
newtype GenericR'
type GenericT
newtype GenericT'

Packagesyb-0.7.4
Exports41
LicenceBSD-3-Clause

valuechoiceMp :: MonadPlus m => GenericM m -> GenericM m -> GenericM m

valuechoiceQ :: MonadPlus m => GenericQ (m r) -> GenericQ (m r) -> GenericQ (m r)

valueext0 :: (Typeable a, Typeable b) => c a -> c b -> c a

valueext1 :: (Data a, Typeable t) => c a -> (forall d. Data d => c (t d)) -> c a

valueext1B :: (Data a, Typeable t) => a -> (forall b. Data b => t b) -> a

valueext1M

:: (Monad m, Data d, Typeable t)
=> forall e. Data e => e -> m e
-> forall f. Data f => t f -> m (t f)
-> d
-> m d

valueext1Q

:: (Data d, Typeable t)
=> d -> q
-> forall e. Data e => t e -> q
-> d
-> q

valueext1R

:: (Monad m, Data d, Typeable t)
=> m d
-> forall e. Data e => m (t e)
-> m d

valueext1T

:: (Data d, Typeable t)
=> forall e. Data e => e -> e
-> forall f. Data f => t f -> t f
-> d
-> d

valueext2

:: (Data a, Typeable t)
=> c a
-> forall d1 d2. (Data d1, Data d2) => c (t d1 d2)
-> c a

valueext2B

:: (Data a, Typeable t)
=> a
-> forall d1 d2. (Data d1, Data d2) => t d1 d2
-> a

valueext2M

:: (Monad m, Data d, Typeable t)
=> forall e. Data e => e -> m e
-> forall d1 d2. (Data d1, Data d2) => t d1 d2 -> m (t d1 d2)
-> d
-> m d

valueext2Q

:: (Data d, Typeable t)
=> d -> q
-> forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q
-> d
-> q

valueext2R

:: (Monad m, Data d, Typeable t)
=> m d
-> forall d1 d2. (Data d1, Data d2) => m (t d1 d2)
-> m d

valueext2T

:: (Data d, Typeable t)
=> forall e. Data e => e -> e
-> forall d1 d2. (Data d1, Data d2) => t d1 d2 -> t d1 d2
-> d
-> d

valueextB :: (Typeable a, Typeable b) => a -> b -> a

valueextM

:: (Monad m, Typeable a, Typeable b)
=> a -> m a
-> b -> m b
-> a
-> m a

valueextMp

:: (MonadPlus m, Typeable a, Typeable b)
=> a -> m a
-> b -> m b
-> a
-> m a

valueextQ :: (Typeable a, Typeable b) => (a -> r) -> (b -> r) -> a -> r

valueextR :: (Monad m, Typeable a, Typeable b) => m a -> m b -> m a

valueextT :: (Typeable a, Typeable b) => (a -> a) -> (b -> b) -> a -> a

valuemkM :: (Monad m, Typeable a, Typeable b) => (b -> m b) -> a -> m a

valuemkMp :: (MonadPlus m, Typeable a, Typeable b) => (b -> m b) -> a -> m a

valuemkQ :: (Typeable a, Typeable b) => r -> (b -> r) -> a -> r

valuemkR :: (MonadPlus m, Typeable a, Typeable b) => m b -> m a

valuemkT :: (Typeable a, Typeable b) => (b -> b) -> a -> a

valueorElse :: Maybe a -> Maybe a -> Maybe a

valuerecoverMp :: MonadPlus m => GenericM m -> GenericM m

valuerecoverQ :: MonadPlus m => r -> GenericQ (m r) -> GenericQ (m r)

typetype Generic (c :: Type -> Type) = forall a. Data a => a -> c a

newtypenewtype Generic' (c :: Type -> Type)

Constructors

Generic'
- unGeneric' :: Generic c

typetype GenericB = forall a. Data a => a

newtypenewtype GenericB'

Constructors

GenericB'
- unGenericB' :: GenericB

typetype GenericM (m :: Type -> Type) = forall a. Data a => a -> m a

newtypenewtype GenericM' (m :: Type -> Type)

Constructors

GM
- unGM :: GenericM m

typetype GenericQ r = forall a. Data a => a -> r

newtypenewtype GenericQ' r

Constructors

GQ
- unGQ :: GenericQ r

typetype GenericR (m :: Type -> Type) = forall a. Data a => m a

newtypenewtype GenericR' (m :: Type -> Type)

Constructors

GenericR'
- unGenericR' :: GenericR m

typetype GenericT = forall a. Data a => a -> a

newtypenewtype GenericT'

Constructors

GT
- unGT :: GenericT