Dep.Env

This module provides helpers for building dependency injection environments composed of records.

It's not necessary when defining the record components themselves, in that case Dep.Has should suffice.

>>> :{
type Logger :: (Type -> Type) -> Type
newtype Logger d = Logger {
    info :: String -> d ()
  }
--
data Repository d = Repository
  { findById :: Int -> d (Maybe String)
  , putById :: Int -> String -> d ()
  , insert :: String -> d Int
  }
--
data Controller d = Controller
  { create :: d Int
  , append :: Int -> String -> d Bool
  , inspect :: Int -> d (Maybe String)
  }
--
type EnvHKD :: (Type -> Type) -> (Type -> Type) -> Type
data EnvHKD h m = EnvHKD
  { logger :: h (Logger m),
    repository :: h (Repository m),
    controller :: h (Controller m)
  } deriving stock Generic
    deriving anyclass (FieldsFindableByType, DemotableFieldNames, Phased)
deriving via Autowired (EnvHKD Identity m) instance Autowireable r_ m (EnvHKD Identity m) => Has r_ m (EnvHKD Identity m)
:}

The module also provides a monad transformer-less way of performing dependency injection, by means of fixEnv.

A general-purpose Has

class Has (r_ :: (Type -> Type) -> Type) (m :: Type -> Type) (deps :: Type) | deps -> m

A generic "Has" class. When partially applied to a parametrizable record-of-functions r_, produces a 2-place constraint saying that the environment deps has the record r_ with effect monad m.

The constraint can be used on its own, or with Control.Monad.Dep.Class.

Instances

(FieldsFindableByType (env_ m), HasField (FindFieldByType (env_ m) (r_ m)) (env_ m) u, Coercible u (r_ m)) => Has r_ m (Autowired (env_ m))

Defined in Dep.Env

Methods

dep :: Autowired (env_ m) -> r_ m

(Dep r_, HasField (DefaultFieldName r_) (env_ m) u, Coercible u (r_ m)) => Has r_ m (TheDefaultFieldName (env_ m))

Defined in Dep.Env

Methods

dep :: TheDefaultFieldName (env_ m) -> r_ m

(HasField name (env_ m) u, Coercible u (r_ m)) => Has r_ m (TheFieldName name (env_ m))

Defined in Dep.Env

Methods

dep :: TheFieldName name (env_ m) -> r_ m

Has r_ m (a, r_ m)

Defined in Dep.Has

Methods

dep :: (a, r_ m) -> r_ m

Has r_ m (r_ m, b)

Defined in Dep.Has

Methods

dep :: (r_ m, b) -> r_ m

InductiveEnvFind r_ m rs => Has r_ m (InductiveEnv rs Identity m)

Works by searching on the list of types.

Defined in Dep.Env

Methods

dep :: InductiveEnv rs Identity m -> r_ m

Has r_ m (a, b, r_ m)

Defined in Dep.Has

Methods

dep :: (a, b, r_ m) -> r_ m

Has r_ m (a, r_ m, c)

Defined in Dep.Has

Methods

dep :: (a, r_ m, c) -> r_ m

Has r_ m (r_ m, b, c)

Defined in Dep.Has

Methods

dep :: (r_ m, b, c) -> r_ m

Has r_ m (a, b, c, r_ m)

Defined in Dep.Has

Methods

dep :: (a, b, c, r_ m) -> r_ m

Has r_ m (a, b, r_ m, d)

Defined in Dep.Has

Methods

dep :: (a, b, r_ m, d) -> r_ m

Has r_ m (a, r_ m, c, d)

Defined in Dep.Has

Methods

dep :: (a, r_ m, c, d) -> r_ m

Has r_ m (r_ m, b, c, d)

Defined in Dep.Has

Methods

dep :: (r_ m, b, c, d) -> r_ m

Helpers for deriving Has

via the default field name

newtype TheDefaultFieldName (env :: Type)

Deprecated: more intrusive than useful

Helper for DerivingVia HasField instances.

It expects the component to have as field name the default fieldname specified by Dep.

This is the same behavior as the DefaultSignatures implementation for Has, so maybe it doesn't make much sense to use it, except for explicitness.

Constructors

TheDefaultFieldName env

Deprecated: more intrusive than useful

Instances

(Dep r_, HasField (DefaultFieldName r_) (env_ m) u, Coercible u (r_ m)) => Has r_ m (TheDefaultFieldName (env_ m))

Defined in Dep.Env

Methods

dep :: TheDefaultFieldName (env_ m) -> r_ m

via arbitrary field name

newtype TheFieldName (name :: Symbol) (env :: Type)

Helper for DerivingVia HasField instances.

The field name is specified as a Symbol.

Constructors

TheFieldName env

Instances

(HasField name (env_ m) u, Coercible u (r_ m)) => Has r_ m (TheFieldName name (env_ m))

Defined in Dep.Env

Methods

dep :: TheFieldName name (env_ m) -> r_ m

via autowiring

class FieldsFindableByType (env :: Type)

Class for getting the field name from the field's type.

The default implementation of FindFieldByType requires a Generic instance, but users can write their own implementations.

Associated Types

type FindFieldByType env (r :: Type) :: Symbol

type FindFieldByType env r = FindFieldByType_ env r

newtype Autowired (env :: Type)

Helper for DerivingVia HasField instances.

The fields are identified by their types.

It uses FindFieldByType under the hood.

BEWARE: for large records with many components, this technique might incur in long compilation times.

Constructors

Autowired env

Instances

(FieldsFindableByType (env_ m), HasField (FindFieldByType (env_ m) (r_ m)) (env_ m) u, Coercible u (r_ m)) => Has r_ m (Autowired (env_ m))

Defined in Dep.Env

Methods

dep :: Autowired (env_ m) -> r_ m

type Autowireable r_ (m :: Type -> Type) (env :: Type) = HasField (FindFieldByType env (r_ m)) env (Identity (r_ m))

Constraints required when DerivingVia all possible instances of Has in a single definition.

This only works for environments where all the fields come wrapped in Data.Functor.Identity.

Inductive environment with anonymous fields

data InductiveEnv (rs :: [(Type -> Type) -> Type]) (h :: Type -> Type) (m :: Type -> Type) where

An inductively constructed environment with anonymous fields.

Can be useful for simple tests. Also for converting Has-based components into functions that take their dependencies as separate positional parameters.

>>> :{
data Logger d = Logger { }
data Repository d = Repository { }
data Controller d = Controller  { }
makeController :: (Monad m, Has Logger m deps, Has Repository m deps) => deps -> Controller m
makeController = undefined
makeControllerPositional :: Monad m => Logger m -> Repository m -> Controller m
makeControllerPositional a b = makeController $ addDep @Logger a $ addDep @Repository b $ emptyEnv
makeController' :: (Monad m, Has Logger m deps, Has Repository m deps) => deps -> Controller m
makeController' deps = makeControllerPositional (dep deps) (dep deps)
:}

Although, for small numbers of components, we can simply use a tuple as the environment:

>>> :{
makeControllerPositional' :: Monad m => Logger m -> Repository m -> Controller m
makeControllerPositional' a b = makeController (a,b)
:}

Constructors

AddDep :: forall r_ m rs h. Typeable r_ => h (r_ m) -> InductiveEnv rs h m -> InductiveEnv (r_ ': rs) h m

EmptyEnv :: forall m h. InductiveEnv '[] h m

Instances

InductiveEnvFind r_ m rs => Has r_ m (InductiveEnv rs Identity m)

Works by searching on the list of types.

Defined in Dep.Env

Methods

dep :: InductiveEnv rs Identity m -> r_ m

Phased (InductiveEnv rs)

Defined in Dep.Env

Methods

traverseH :: forall h f g (m :: Type -> Type). (Applicative f, Typeable f, Typeable g, Typeable h, Typeable m) => (forall x. Typeable x => h x -> f (g x)) -> InductiveEnv rs h m -> f (InductiveEnv rs g m)

liftA2H :: forall a f f' (m :: Type -> Type). (Typeable a, Typeable f, Typeable f', Typeable m) => (forall x. Typeable x => a x -> f x -> f' x) -> InductiveEnv rs a m -> InductiveEnv rs f m -> InductiveEnv rs f' m

addDep :: forall r_ m rs. Typeable r_ => r_ m -> InductiveEnv rs Identity m -> InductiveEnv (r_ ': rs) Identity m

Unlike the AddDep constructor, this sets h to Identity.

emptyEnv :: forall m. InductiveEnv '[] Identity m

Unlike the EmptyEnv constructor, this sets h to Identity.

Managing phases

class Phased (env_ :: (Type -> Type) -> (Type -> Type) -> Type) where

Class of 2-parameter environments for which the first parameter h wraps each field and corresponds to phases in the construction of the environment, and the second parameter m is the effect monad used by each component.

h will typically be a composition of applicative functors, each one representing a phase. We advance through the phases by "pulling out" the outermost phase and running it in some way, until we are are left with a Constructor phase, which we can remove using fixEnv.

Phased resembles FunctorT, TraversableT and ApplicativeT from the barbies library, although Phased instances can't be written in terms of them because of the extra Typeable constraints.

Minimal complete definition

Nothing

Methods

traverseH

Arguments

:: forall (h :: Type -> Type) (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type). (Applicative f, Typeable f, Typeable g, Typeable h, Typeable m)

=> (forall x. Typeable x => h x -> f (g x))

Transform to be applied to each field.

-> env_ h m

-> f (env_ g m)

Used to implement pullPhase and mapPhase, typically you should use those functions instead.

default traverseH :: forall (h :: Type -> Type) (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type). (Applicative f, Typeable f, Typeable g, Typeable h, Typeable m, Generic (env_ h m), Generic (env_ g m), GTraverseH h g (Rep (env_ h m)) (Rep (env_ g m))) => (forall x. Typeable x => h x -> f (g x)) -> env_ h m -> f (env_ g m)

liftA2H

Arguments

:: forall (a :: Type -> Type) (f :: Type -> Type) (f' :: Type -> Type) (m :: Type -> Type). (Typeable a, Typeable f, Typeable f', Typeable m)

=> (forall x. Typeable x => a x -> f x -> f' x)

Transform to be applied to each field.

-> env_ a m

-> env_ f m

-> env_ f' m

Used to implement liftA2Phase, typically you should use that function instead.

default liftA2H :: forall (a :: Type -> Type) (f :: Type -> Type) (f' :: Type -> Type) m. (Typeable a, Typeable f, Typeable f', Typeable m, Generic (env_ a m), Generic (env_ f m), Generic (env_ f' m), GLiftA2Phase a f f' (Rep (env_ a m)) (Rep (env_ f m)) (Rep (env_ f' m))) => (forall x. Typeable x => a x -> f x -> f' x) -> env_ a m -> env_ f m -> env_ f' m

Instances

Phased (InductiveEnv rs)

Defined in Dep.Env

Methods

traverseH :: forall h f g (m :: Type -> Type). (Applicative f, Typeable f, Typeable g, Typeable h, Typeable m) => (forall x. Typeable x => h x -> f (g x)) -> InductiveEnv rs h m -> f (InductiveEnv rs g m)

liftA2H :: forall a f f' (m :: Type -> Type). (Typeable a, Typeable f, Typeable f', Typeable m) => (forall x. Typeable x => a x -> f x -> f' x) -> InductiveEnv rs a m -> InductiveEnv rs f m -> InductiveEnv rs f' m

liftAH

Arguments

:: forall deps_ phases phases' m. (Phased deps_, Typeable phases, Typeable phases', Typeable m)

=> (forall x. Typeable x => phases x -> phases' x)

Transform to be applied to each field.

-> deps_ phases m

-> deps_ phases' m

Slightly less powerful version of traverseH.

pullPhase

Arguments

:: forall (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) env_. (Phased env_, Applicative f, Typeable f, Typeable g, Typeable m)

=> env_ (Compose f g) m

-> f (env_ g m)

Environment with the outer Applicative layer pulled outward.

Take the outermost phase wrapping each component and "pull it outwards", aggregating the phase's applicative effects.

>>> :{
 newtype Foo d = Foo {foo :: String -> d ()} deriving Generic
 makeIOFoo :: MonadIO m => Foo m
 makeIOFoo = Foo (liftIO . putStrLn)
 env :: InductiveEnv '[Foo] (IO `Compose` Constructor (InductiveEnv '[Foo] Identity IO)) IO
 env = EmptyEnv
     & AddDep @Foo (putStrLn "io phase" `bindPhase` \() -> constructor (\_ -> makeIOFoo))
 ioOutside :: IO (InductiveEnv '[Foo] (Constructor (InductiveEnv '[Foo] Identity IO)) IO)
 ioOutside = pullPhase env
:}

mapPhase

Arguments

:: forall (f :: Type -> Type) (f' :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) env_. (Phased env_, Typeable f, Typeable f', Typeable g, Typeable m)

=> (forall x. Typeable x => f x -> f' x)

Transform to be applied to each field.

-> env_ (Compose f g) m

-> env_ (Compose f' g) m

Modify the outermost phase wrapping each component.

>>> :{
 newtype Foo d = Foo {foo :: String -> d ()} deriving Generic
 makeIOFoo :: MonadIO m => Foo m
 makeIOFoo = Foo (liftIO . putStrLn)
 env :: InductiveEnv '[Foo] ((,) Int `Compose` Constructor String) IO
 env = EmptyEnv
     & AddDep @Foo ((2,()) `bindPhase` \() -> constructor (\_ -> makeIOFoo))
 env' :: InductiveEnv '[Foo] ((,) String `Compose` Constructor String) IO
 env' = mapPhase (\(n,x) -> (show n,x)) env
:}

liftA2Phase

Arguments

:: forall (a :: Type -> Type) (f' :: Type -> Type) (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) env_. (Phased env_, Typeable a, Typeable f, Typeable f', Typeable g, Typeable m)

=> (forall x. Typeable x => a x -> f x -> f' x)

Binary operation to combine corresponding fields.

-> env_ (Compose a g) m

-> env_ (Compose f g) m

-> env_ (Compose f' g) m

Combine two environments with a function that works on their outermost phases.

Working with field names

class DemotableFieldNames env_ where

Deprecated: using the field names directly is usually a bad idea

Class of 2-parameter environments for which it's possible to obtain the names of each field as values.

Minimal complete definition

Nothing

Methods

demoteFieldNamesH :: (forall x. String -> h String x) -> env_ (h String) m

default demoteFieldNamesH :: (Generic (env_ (h String) m), GDemotableFieldNamesH h (Rep (env_ (h String) m))) => (forall x. String -> h String x) -> env_ (h String) m

demoteFieldNames :: forall env_ m. DemotableFieldNames env_ => env_ (Constant String) m

Deprecated: using the field names directly is usually a bad idea

Bring down the field names of the environment to the term level and store them in the accumulator of Data.Functor.Constant.

mapPhaseWithFieldNames

Arguments

:: forall (f :: Type -> Type) (f' :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) env_. (Phased env_, DemotableFieldNames env_, Typeable f, Typeable f', Typeable g, Typeable m)

=> (forall x. Typeable x => String -> f x -> f' x)

Transform to be applied to each field. Has access to the field name.

-> env_ (Compose f g) m

-> env_ (Compose f' g) m

Deprecated: using the field names directly is usually a bad idea

Modify the outermost phase wrapping each component, while having access to the field name of the component.

A typical usage is modifying a "parsing the configuration" phase so that each component looks into a different section of the global configuration field.

Constructing phases

bindPhase and skipPhase are small convenience functions to help build nested compositions of functors.

bindPhase :: forall f g a b. Functor f => f a -> (a -> g b) -> Compose f g b

Use the result of the previous phase to build the next one.

Can be useful infix.

>>> :{
 type Phases = IO `Compose` IO `Compose` Identity
 phased :: Phases Int
 phased =
     pure 1 `bindPhase` \i1 ->
     pure 2 `bindPhase` \i2 ->
     Identity (i1 + i2)
:}

A possible alternative is >>= from Dep.Phases used in combination with -XQualifiedDo.

skipPhase :: forall f g a. Applicative f => g a -> Compose f g a

Deprecated: use pure () in combination with bindPhase

Don't do anything for the current phase, just wrap the next one.

>>> :{
 type Phases = IO `Compose` IO `Compose` Identity
 phased :: Phases Int
 phased =
     skipPhase $
     skipPhase $
     Identity 1
:}

fromBare and toBare are an alternative method to build nested compositions of functors, which relies on "coerce".

type family Bare x where ...

This type family clears newtypes like Compose, Identity and Constant from a composite type, leaving you with a newtypeless nested type as result.

The idea is that it might be easier to construct values of the "bare" version of a composite type, and later coerce them to the newtyped version using fromBare.

This is mainly intended for defining the nested Applicative "phases" of components that live in a Phased environment. It's an alternative to functions like bindPhase and skipPhase.

Equations

Bare (Compose outer inner x) = Bare (outer (Bare (inner x)))

Bare (Identity x) = x

Bare (Const x k) = x

Bare (Constant x k) = x

Bare other = other

fromBare :: Coercible phases (Bare phases) => Bare phases -> phases

Convert a value from its bare version to the newtyped one, usually as a step towards inserting it into a Phased environment.

>>> :{
type Phases = IO `Compose` IO `Compose` IO
wrapped :: Phases Int = fromBare $ pure $ pure $ pure 3
:}

>>> :{
type Phases = Constructor Int
wrapped :: Phases Int
wrapped = fromBare $ succ
:}

>>> :{
type Phases = IO `Compose` Constructor Int
wrapped :: Phases Int
wrapped = fromBare $ pure $ succ
:}

toBare :: Coercible phases (Bare phases) => phases -> Bare phases

Convert from the newtyped value to the bare one. fromBare tends to be more useful.

Injecting dependencies by tying the knot

fixEnv

Arguments

:: (Phased env_, Typeable env_, Typeable m)

=> env_ (Constructor (env_ Identity m)) m

Environment where each field is wrapped in a Constructor

-> env_ Identity m

Fully constructed environment, ready for use.

Deprecated: use the one in Dep.Constructor

This is a method of performing dependency injection that doesn't require Control.Monad.Dep.DepT at all. In fact, it doesn't require the use of any monad transformer!

If we have a environment whose fields are functions that construct each component by searching for its dependencies in a "fully built" version of the environment, we can "tie the knot" to obtain the "fully built" environment. This works as long as there aren't any circular dependencies between components.

Think of it as a version of fix that, instead of "tying" a single function, ties a whole record of them.

The env_ (Constructor (env_ Identity m)) m parameter might be the result of peeling away successive layers of applicative functor composition using pullPhase, until only the wiring phase remains.

>>> :{
newtype Foo d = Foo {foo :: String -> d ()} deriving Generic
newtype Bar d = Bar {bar :: String -> d ()} deriving Generic
makeIOFoo :: MonadIO m => Foo m
makeIOFoo = Foo (liftIO . putStrLn)
makeBar :: Has Foo m env => env -> Bar m
makeBar (asCall -> call) = Bar (call foo)
env :: InductiveEnv [Bar,Foo] (Constructor (InductiveEnv [Bar,Foo] Identity IO)) IO
env = EmptyEnv
    & AddDep @Foo (constructor (\_ -> makeIOFoo))
    & AddDep @Bar (constructor makeBar)
envReady :: InductiveEnv [Bar,Foo] Identity IO
envReady = fixEnv env
 :}

>>> :{
 bar (dep envReady) "this is bar"
:}
this is bar

type Constructor (env :: Type) = (->) env `Compose` Identity

Deprecated: use the one in Dep.Constructor

A phase with the effect of "constructing each component by reading its dependencies from a completed environment". It should be the final phase.

The Constructor phase for an environment will typically be parameterized with the environment itself.

constructor :: forall r_ m env. (env -> r_ m) -> Constructor env (r_ m)

Deprecated: use the one in Dep.Constructor

Turn an environment-consuming function into a Constructor that can be slotted into some field of a Phased environment.

fixEnvAccum

Arguments

:: (Phased env_, Typeable env_, Typeable m, Monoid w, Typeable w)

=> env_ (AccumConstructor w (env_ Identity m)) m

Environment where each field is wrapped in an AccumConstructor

-> (w, env_ Identity m)

Fully constructed accumulator and environment, ready for use.

Deprecated: use the one in Dep.Constructor

A generalized version of fixEnv which threads a monoidal accumulator along with the environment.

Sometimes, we need constructors to produce a monoidal value along with the component. Think for example about some kind of composable startup action for the component.

And on the input side, some constructors need access to the monoidal value accumulated across all components. Think for example about a component which publishes accumulated diagnostics coming from all other components.

LAZY PATTERN MATCH REQUIRED! Any constructor that matches on the (accumulator, environment) tuple needs to use a lazy pattern match like ~(w,env). Otherwise fixEnvAccum enters an infinite loop! Such are the dangers of knot-tying.

type AccumConstructor (w :: Type) (env :: Type) = (->) (w, env) `Compose` ((,) w `Compose` Identity)

Deprecated: use the one in Dep.Constructor

A generalization of Constructor which produces, in addition to the result value, a value w which is then aggregated across all components and fed back along with the completed environment.

Like Constructor, AccumConstructor should be the final phase.

Re-exports

newtype Identity a

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity

Fields

• runIdentity :: a

Instances

MonadFix Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

mfix :: (a -> Identity a) -> Identity a

MonadZip Identity

Since: base-4.8.0.0

Defined in Control.Monad.Zip

Methods

mzip :: Identity a -> Identity b -> Identity (a, b)

mzipWith :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

munzip :: Identity (a, b) -> (Identity a, Identity b)

Foldable Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fold :: Monoid m => Identity m -> m

foldMap :: Monoid m => (a -> m) -> Identity a -> m

foldMap' :: Monoid m => (a -> m) -> Identity a -> m

foldr :: (a -> b -> b) -> b -> Identity a -> b

foldr' :: (a -> b -> b) -> b -> Identity a -> b

foldl :: (b -> a -> b) -> b -> Identity a -> b

foldl' :: (b -> a -> b) -> b -> Identity a -> b

foldr1 :: (a -> a -> a) -> Identity a -> a

foldl1 :: (a -> a -> a) -> Identity a -> a

toList :: Identity a -> [a]

null :: Identity a -> Bool

length :: Identity a -> Int

elem :: Eq a => a -> Identity a -> Bool

maximum :: Ord a => Identity a -> a

minimum :: Ord a => Identity a -> a

sum :: Num a => Identity a -> a

product :: Num a => Identity a -> a

Traversable Identity

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b)

sequenceA :: Applicative f => Identity (f a) -> f (Identity a)

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b)

sequence :: Monad m => Identity (m a) -> m (Identity a)

Applicative Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

pure :: a -> Identity a

(<*>) :: Identity (a -> b) -> Identity a -> Identity b

liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

(*>) :: Identity a -> Identity b -> Identity b

(<*) :: Identity a -> Identity b -> Identity a

Functor Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fmap :: (a -> b) -> Identity a -> Identity b

(<$) :: a -> Identity b -> Identity a

Monad Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

(>>=) :: Identity a -> (a -> Identity b) -> Identity b

(>>) :: Identity a -> Identity b -> Identity b

return :: a -> Identity a

Generic1 Identity

Defined in Data.Functor.Identity

Associated Types

type Rep1 Identity :: k -> Type

Methods

from1 :: forall (a :: k). Identity a -> Rep1 Identity a

to1 :: forall (a :: k). Rep1 Identity a -> Identity a

InductiveEnvFind r_ m rs => Has r_ m (InductiveEnv rs Identity m)

Works by searching on the list of types.

Defined in Dep.Env

Methods

dep :: InductiveEnv rs Identity m -> r_ m

IsString a => IsString (Identity a)

Since: base-4.9.0.0

Defined in Data.String

Methods

fromString :: String -> Identity a

Storable a => Storable (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

sizeOf :: Identity a -> Int

alignment :: Identity a -> Int

peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a)

pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Identity a)

pokeByteOff :: Ptr b -> Int -> Identity a -> IO ()

peek :: Ptr (Identity a) -> IO (Identity a)

poke :: Ptr (Identity a) -> Identity a -> IO ()

Monoid a => Monoid (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

Semigroup a => Semigroup (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

(<>) :: Identity a -> Identity a -> Identity a

sconcat :: NonEmpty (Identity a) -> Identity a

stimes :: Integral b => b -> Identity a -> Identity a

Bits a => Bits (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

(.&.) :: Identity a -> Identity a -> Identity a

(.|.) :: Identity a -> Identity a -> Identity a

xor :: Identity a -> Identity a -> Identity a

complement :: Identity a -> Identity a

shift :: Identity a -> Int -> Identity a

rotate :: Identity a -> Int -> Identity a

zeroBits :: Identity a

bit :: Int -> Identity a

setBit :: Identity a -> Int -> Identity a

clearBit :: Identity a -> Int -> Identity a

complementBit :: Identity a -> Int -> Identity a

testBit :: Identity a -> Int -> Bool

bitSizeMaybe :: Identity a -> Maybe Int

bitSize :: Identity a -> Int

isSigned :: Identity a -> Bool

shiftL :: Identity a -> Int -> Identity a

unsafeShiftL :: Identity a -> Int -> Identity a

shiftR :: Identity a -> Int -> Identity a

unsafeShiftR :: Identity a -> Int -> Identity a

rotateL :: Identity a -> Int -> Identity a

rotateR :: Identity a -> Int -> Identity a

popCount :: Identity a -> Int

FiniteBits a => FiniteBits (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

finiteBitSize :: Identity a -> Int

countLeadingZeros :: Identity a -> Int

countTrailingZeros :: Identity a -> Int

Bounded a => Bounded (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

minBound :: Identity a

maxBound :: Identity a

Enum a => Enum (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

succ :: Identity a -> Identity a

pred :: Identity a -> Identity a

toEnum :: Int -> Identity a

fromEnum :: Identity a -> Int

enumFrom :: Identity a -> [Identity a]

enumFromThen :: Identity a -> Identity a -> [Identity a]

enumFromTo :: Identity a -> Identity a -> [Identity a]

enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a]

Floating a => Floating (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

pi :: Identity a

exp :: Identity a -> Identity a

log :: Identity a -> Identity a

sqrt :: Identity a -> Identity a

(**) :: Identity a -> Identity a -> Identity a

logBase :: Identity a -> Identity a -> Identity a

sin :: Identity a -> Identity a

cos :: Identity a -> Identity a

tan :: Identity a -> Identity a

asin :: Identity a -> Identity a

acos :: Identity a -> Identity a

atan :: Identity a -> Identity a

sinh :: Identity a -> Identity a

cosh :: Identity a -> Identity a

tanh :: Identity a -> Identity a

asinh :: Identity a -> Identity a

acosh :: Identity a -> Identity a

atanh :: Identity a -> Identity a

log1p :: Identity a -> Identity a

expm1 :: Identity a -> Identity a

log1pexp :: Identity a -> Identity a

log1mexp :: Identity a -> Identity a

RealFloat a => RealFloat (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

floatRadix :: Identity a -> Integer

floatDigits :: Identity a -> Int

floatRange :: Identity a -> (Int, Int)

decodeFloat :: Identity a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Identity a

exponent :: Identity a -> Int

significand :: Identity a -> Identity a

scaleFloat :: Int -> Identity a -> Identity a

isNaN :: Identity a -> Bool

isInfinite :: Identity a -> Bool

isDenormalized :: Identity a -> Bool

isNegativeZero :: Identity a -> Bool

isIEEE :: Identity a -> Bool

atan2 :: Identity a -> Identity a -> Identity a

Generic (Identity a)

Defined in Data.Functor.Identity

Associated Types

type Rep (Identity a) :: Type -> Type

Methods

from :: Identity a -> Rep (Identity a) x

to :: Rep (Identity a) x -> Identity a

Ix a => Ix (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

range :: (Identity a, Identity a) -> [Identity a]

index :: (Identity a, Identity a) -> Identity a -> Int

unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int

inRange :: (Identity a, Identity a) -> Identity a -> Bool

rangeSize :: (Identity a, Identity a) -> Int

unsafeRangeSize :: (Identity a, Identity a) -> Int

Num a => Num (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

(+) :: Identity a -> Identity a -> Identity a

(-) :: Identity a -> Identity a -> Identity a

(*) :: Identity a -> Identity a -> Identity a

negate :: Identity a -> Identity a

abs :: Identity a -> Identity a

signum :: Identity a -> Identity a

fromInteger :: Integer -> Identity a

Read a => Read (Identity a)

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

readsPrec :: Int -> ReadS (Identity a)

readList :: ReadS [Identity a]

readPrec :: ReadPrec (Identity a)

readListPrec :: ReadPrec [Identity a]

Fractional a => Fractional (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

(/) :: Identity a -> Identity a -> Identity a

recip :: Identity a -> Identity a

fromRational :: Rational -> Identity a

Integral a => Integral (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

quot :: Identity a -> Identity a -> Identity a

rem :: Identity a -> Identity a -> Identity a

div :: Identity a -> Identity a -> Identity a

mod :: Identity a -> Identity a -> Identity a

quotRem :: Identity a -> Identity a -> (Identity a, Identity a)

divMod :: Identity a -> Identity a -> (Identity a, Identity a)

toInteger :: Identity a -> Integer

Real a => Real (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

toRational :: Identity a -> Rational

RealFrac a => RealFrac (Identity a)

Since: base-4.9.0.0

Defined in Data.Functor.Identity

Methods

properFraction :: Integral b => Identity a -> (b, Identity a)

truncate :: Integral b => Identity a -> b

round :: Integral b => Identity a -> b

ceiling :: Integral b => Identity a -> b

floor :: Integral b => Identity a -> b

Show a => Show (Identity a)

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

showsPrec :: Int -> Identity a -> ShowS

show :: Identity a -> String

showList :: [Identity a] -> ShowS

Eq a => Eq (Identity a)

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

(==) :: Identity a -> Identity a -> Bool

(/=) :: Identity a -> Identity a -> Bool

Ord a => Ord (Identity a)

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

compare :: Identity a -> Identity a -> Ordering

(<) :: Identity a -> Identity a -> Bool

(<=) :: Identity a -> Identity a -> Bool

(>) :: Identity a -> Identity a -> Bool

(>=) :: Identity a -> Identity a -> Bool

max :: Identity a -> Identity a -> Identity a

min :: Identity a -> Identity a -> Identity a

type Rep1 Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

type Rep1 Identity = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

type Rep (Identity a)

Since: base-4.8.0.0

Defined in Data.Functor.Identity

type Rep (Identity a) = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype Constant a (b :: k)

Constant functor.

Constructors

Constant

Fields

• getConstant :: a

Instances

Bifoldable (Constant :: Type -> TYPE LiftedRep -> Type)

Defined in Data.Functor.Constant

Methods

bifold :: Monoid m => Constant m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Constant a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Constant a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Constant a b -> c

Bifunctor (Constant :: Type -> Type -> Type)

Defined in Data.Functor.Constant

Methods

bimap :: (a -> b) -> (c -> d) -> Constant a c -> Constant b d

first :: (a -> b) -> Constant a c -> Constant b c

second :: (b -> c) -> Constant a b -> Constant a c

Bitraversable (Constant :: Type -> Type -> Type)

Defined in Data.Functor.Constant

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Constant a b -> f (Constant c d)

Eq2 (Constant :: Type -> Type -> Type)

Defined in Data.Functor.Constant

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Constant a c -> Constant b d -> Bool

Ord2 (Constant :: Type -> Type -> Type)

Defined in Data.Functor.Constant

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Constant a c -> Constant b d -> Ordering

Read2 (Constant :: Type -> Type -> Type)

Defined in Data.Functor.Constant

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Constant a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Constant a b]

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Constant a b)

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Constant a b]

Show2 (Constant :: Type -> TYPE LiftedRep -> Type)

Defined in Data.Functor.Constant

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Constant a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Constant a b] -> ShowS

Foldable (Constant a :: TYPE LiftedRep -> Type)

Defined in Data.Functor.Constant

Methods

fold :: Monoid m => Constant a m -> m

foldMap :: Monoid m => (a0 -> m) -> Constant a a0 -> m

foldMap' :: Monoid m => (a0 -> m) -> Constant a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Constant a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Constant a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Constant a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Constant a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0

toList :: Constant a a0 -> [a0]

null :: Constant a a0 -> Bool

length :: Constant a a0 -> Int

elem :: Eq a0 => a0 -> Constant a a0 -> Bool

maximum :: Ord a0 => Constant a a0 -> a0

minimum :: Ord a0 => Constant a a0 -> a0

sum :: Num a0 => Constant a a0 -> a0

product :: Num a0 => Constant a a0 -> a0

Eq a => Eq1 (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

liftEq :: (a0 -> b -> Bool) -> Constant a a0 -> Constant a b -> Bool

Ord a => Ord1 (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

liftCompare :: (a0 -> b -> Ordering) -> Constant a a0 -> Constant a b -> Ordering

Read a => Read1 (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Constant a a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Constant a a0]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Constant a a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Constant a a0]

Show a => Show1 (Constant a :: TYPE LiftedRep -> Type)

Defined in Data.Functor.Constant

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Constant a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Constant a a0] -> ShowS

Contravariant (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

contramap :: (a' -> a0) -> Constant a a0 -> Constant a a'

(>$) :: b -> Constant a b -> Constant a a0

Traversable (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

traverse :: Applicative f => (a0 -> f b) -> Constant a a0 -> f (Constant a b)

sequenceA :: Applicative f => Constant a (f a0) -> f (Constant a a0)

mapM :: Monad m => (a0 -> m b) -> Constant a a0 -> m (Constant a b)

sequence :: Monad m => Constant a (m a0) -> m (Constant a a0)

Monoid a => Applicative (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

pure :: a0 -> Constant a a0

(<*>) :: Constant a (a0 -> b) -> Constant a a0 -> Constant a b

liftA2 :: (a0 -> b -> c) -> Constant a a0 -> Constant a b -> Constant a c

(*>) :: Constant a a0 -> Constant a b -> Constant a b

(<*) :: Constant a a0 -> Constant a b -> Constant a a0

Functor (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

fmap :: (a0 -> b) -> Constant a a0 -> Constant a b

(<$) :: a0 -> Constant a b -> Constant a a0

Monoid a => Monoid (Constant a b)

Defined in Data.Functor.Constant

Methods

mempty :: Constant a b

mappend :: Constant a b -> Constant a b -> Constant a b

mconcat :: [Constant a b] -> Constant a b

Semigroup a => Semigroup (Constant a b)

Defined in Data.Functor.Constant

Methods

(<>) :: Constant a b -> Constant a b -> Constant a b

sconcat :: NonEmpty (Constant a b) -> Constant a b

stimes :: Integral b0 => b0 -> Constant a b -> Constant a b

Read a => Read (Constant a b)

Defined in Data.Functor.Constant

Methods

readsPrec :: Int -> ReadS (Constant a b)

readList :: ReadS [Constant a b]

readPrec :: ReadPrec (Constant a b)

readListPrec :: ReadPrec [Constant a b]

Show a => Show (Constant a b)

Defined in Data.Functor.Constant

Methods

showsPrec :: Int -> Constant a b -> ShowS

show :: Constant a b -> String

showList :: [Constant a b] -> ShowS

Eq a => Eq (Constant a b)

Defined in Data.Functor.Constant

Methods

(==) :: Constant a b -> Constant a b -> Bool

(/=) :: Constant a b -> Constant a b -> Bool

Ord a => Ord (Constant a b)

Defined in Data.Functor.Constant

Methods

compare :: Constant a b -> Constant a b -> Ordering

(<) :: Constant a b -> Constant a b -> Bool

(<=) :: Constant a b -> Constant a b -> Bool

(>) :: Constant a b -> Constant a b -> Bool

(>=) :: Constant a b -> Constant a b -> Bool

max :: Constant a b -> Constant a b -> Constant a b

min :: Constant a b -> Constant a b -> Constant a b

newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) infixr 9

Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.

Constructors

Compose infixr 9

Fields

• getCompose :: f (g a)

Instances

TestEquality f => TestEquality (Compose f g :: k2 -> Type)

The deduction (via generativity) that if g x :~: g y then x :~: y.

Since: base-4.14.0.0

Defined in Data.Functor.Compose

Methods

testEquality :: forall (a :: k) (b :: k). Compose f g a -> Compose f g b -> Maybe (a :~: b)

Functor f => Generic1 (Compose f g :: k -> Type)

Defined in Data.Functor.Compose

Associated Types

type Rep1 (Compose f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a

to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a

(Foldable f, Foldable g) => Foldable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fold :: Monoid m => Compose f g m -> m

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

foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m

foldr :: (a -> b -> b) -> b -> Compose f g a -> b

foldr' :: (a -> b -> b) -> b -> Compose f g a -> b

foldl :: (b -> a -> b) -> b -> Compose f g a -> b

foldl' :: (b -> a -> b) -> b -> Compose f g a -> b

foldr1 :: (a -> a -> a) -> Compose f g a -> a

foldl1 :: (a -> a -> a) -> Compose f g a -> a

toList :: Compose f g a -> [a]

null :: Compose f g a -> Bool

length :: Compose f g a -> Int

elem :: Eq a => a -> Compose f g a -> Bool

maximum :: Ord a => Compose f g a -> a

minimum :: Ord a => Compose f g a -> a

sum :: Num a => Compose f g a -> a

product :: Num a => Compose f g a -> a

(Eq1 f, Eq1 g) => Eq1 (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

liftEq :: (a -> b -> Bool) -> Compose f g a -> Compose f g b -> Bool

(Ord1 f, Ord1 g) => Ord1 (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

liftCompare :: (a -> b -> Ordering) -> Compose f g a -> Compose f g b -> Ordering

(Read1 f, Read1 g) => Read1 (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Compose f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Compose f g a]

(Show1 f, Show1 g) => Show1 (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Compose f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose f g a] -> ShowS

(Traversable f, Traversable g) => Traversable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b)

sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a)

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

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

(Alternative f, Applicative g) => Alternative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

empty :: Compose f g a

(<|>) :: Compose f g a -> Compose f g a -> Compose f g a

some :: Compose f g a -> Compose f g [a]

many :: Compose f g a -> Compose f g [a]

(Applicative f, Applicative g) => Applicative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

pure :: a -> Compose f g a

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

liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

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

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

(Functor f, Functor g) => Functor (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fmap :: (a -> b) -> Compose f g a -> Compose f g b

(<$) :: a -> Compose f g b -> Compose f g a

(Typeable a, Typeable f, Typeable g, Typeable k1, Typeable k2, Data (f (g a))) => Data (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

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

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

toConstr :: Compose f g a -> Constr

dataTypeOf :: Compose f g a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Compose f g a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose f g a))

gmapT :: (forall b. Data b => b -> b) -> Compose f g a -> Compose f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a)

Monoid (f (g a)) => Monoid (Compose f g a)

Since: base-4.16.0.0

Defined in Data.Functor.Compose

Methods

mempty :: Compose f g a

mappend :: Compose f g a -> Compose f g a -> Compose f g a

mconcat :: [Compose f g a] -> Compose f g a

Semigroup (f (g a)) => Semigroup (Compose f g a)

Since: base-4.16.0.0

Defined in Data.Functor.Compose

Methods

(<>) :: Compose f g a -> Compose f g a -> Compose f g a

sconcat :: NonEmpty (Compose f g a) -> Compose f g a

stimes :: Integral b => b -> Compose f g a -> Compose f g a

Generic (Compose f g a)

Defined in Data.Functor.Compose

Associated Types

type Rep (Compose f g a) :: Type -> Type

Methods

from :: Compose f g a -> Rep (Compose f g a) x

to :: Rep (Compose f g a) x -> Compose f g a

(Read1 f, Read1 g, Read a) => Read (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

readsPrec :: Int -> ReadS (Compose f g a)

readList :: ReadS [Compose f g a]

readPrec :: ReadPrec (Compose f g a)

readListPrec :: ReadPrec [Compose f g a]

(Show1 f, Show1 g, Show a) => Show (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

showsPrec :: Int -> Compose f g a -> ShowS

show :: Compose f g a -> String

showList :: [Compose f g a] -> ShowS

(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

(==) :: Compose f g a -> Compose f g a -> Bool

(/=) :: Compose f g a -> Compose f g a -> Bool

(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

compare :: Compose f g a -> Compose f g a -> Ordering

(<) :: Compose f g a -> Compose f g a -> Bool

(<=) :: Compose f g a -> Compose f g a -> Bool

(>) :: Compose f g a -> Compose f g a -> Bool

(>=) :: Compose f g a -> Compose f g a -> Bool

max :: Compose f g a -> Compose f g a -> Compose f g a

min :: Compose f g a -> Compose f g a -> Compose f g a

type Rep1 (Compose f g :: k -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

type Rep1 (Compose f g :: k -> Type) = D1 ('MetaData "Compose" "Data.Functor.Compose" "base" 'True) (C1 ('MetaCons "Compose" 'PrefixI 'True) (S1 ('MetaSel ('Just "getCompose") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (f :.: Rec1 g)))

type Rep (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

type Rep (Compose f g a) = D1 ('MetaData "Compose" "Data.Functor.Compose" "base" 'True) (C1 ('MetaCons "Compose" 'PrefixI 'True) (S1 ('MetaSel ('Just "getCompose") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (g a)))))