Copyright | (C) 2012-16 Edward Kmett |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | Edward Kmett <ekmett@gmail.com> |
Stability | provisional |
Portability | Rank2Types |
Safe Haskell | Trustworthy |
Language | Haskell2010 |
Control.Lens.Getter
Description
A
is just any function
Getter
s a
(s -> a)
, which we've flipped
into continuation passing style,
(a -> r) -> s -> r
and decorated
with
Const
to obtain:
typeGetting
r s a = (a ->Const
r a) -> s ->Const
r s
If we restrict access to knowledge about the type
r
, we could get:
typeGetter
s a = forall r.Getting
r s a
However, for
Getter
(but not for
Getting
) we actually permit any
functor
f
which is an instance of both
Functor
and
Contravariant
:
typeGetter
s a = forall f. (Contravariant
f,Functor
f) => (a -> f a) -> s -> f s
Everything you can do with a function, you can do with a
Getter
, but
note that because of the continuation passing style (
.
) composes them
in the opposite order.
Since it is only a function, every
Getter
obviously only retrieves a
single value for a given input.
A common question is whether you can combine multiple
Getter
s to
retrieve multiple values. Recall that all
Getter
s are
Fold
s and that
we have a
instance to play
with. Knowing this, we can use
Monoid
m =>
Applicative
(
Const
m)
to glue
<>
Fold
s
together:
>>>
(1, 2, 3, 4, 5) ^.. (_2 <> _3 <> _5)
[2,3,5]
Synopsis
- type Getter s a = forall f. ( Contravariant f, Functor f) => (a -> f a) -> s -> f s
- type IndexedGetter i s a = forall p f. ( Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s
- type Getting r s a = (a -> Const r a) -> s -> Const r s
- type IndexedGetting i m s a = Indexed i a ( Const m a) -> s -> Const m s
- type Accessing p m s a = p a ( Const m a) -> s -> Const m s
- to :: ( Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a
- ito :: ( Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a
- like :: ( Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
- ilike :: ( Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
- (^.) :: s -> Getting a s a -> a
- view :: MonadReader s m => Getting a s a -> m a
- views :: MonadReader s m => LensLike' ( Const r) s a -> (a -> r) -> m r
- use :: MonadState s m => Getting a s a -> m a
- uses :: MonadState s m => LensLike' ( Const r) s a -> (a -> r) -> m r
- listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
- listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v)
- (^@.) :: s -> IndexedGetting i (i, a) s a -> (i, a)
- iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
- iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
- iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
- iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
- ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
- ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v)
- class Contravariant (f :: Type -> Type ) where
- getting :: ( Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
-
newtype
Const
a (b :: k) =
Const
{
- getConst :: a
Getters
type Getter s a = forall f. ( Contravariant f, Functor f) => (a -> f a) -> s -> f s Source #
A
Getter
describes how to retrieve a single value in a way that can be
composed with other
LensLike
constructions.
Unlike a
Lens
a
Getter
is read-only. Since a
Getter
cannot be used to write back there are no
Lens
laws that can be applied to
it. In fact, it is isomorphic to an arbitrary function from
(s -> a)
.
Moreover, a
Getter
can be used directly as a
Fold
,
since it just ignores the
Applicative
.
type IndexedGetter i s a = forall p f. ( Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s Source #
Every
IndexedGetter
is a valid
IndexedFold
and can be used for
Getting
like a
Getter
.
type Getting r s a = (a -> Const r a) -> s -> Const r s Source #
When you see this in a type signature it indicates that you can
pass the function a
Lens
,
Getter
,
Traversal
,
Fold
,
Prism
,
Iso
, or one of
the indexed variants, and it will just "do the right thing".
Most
Getter
combinators are able to be used with both a
Getter
or a
Fold
in limited situations, to do so, they need to be
monomorphic in what we are going to extract with
Const
. To be compatible
with
Lens
,
Traversal
and
Iso
we also restricted choices of the irrelevant
t
and
b
parameters.
If a function accepts a
, then when
Getting
r s a
r
is a
Monoid
, then
you can pass a
Fold
(or
Traversal
), otherwise you can only pass this a
Getter
or
Lens
.
type IndexedGetting i m s a = Indexed i a ( Const m a) -> s -> Const m s Source #
Used to consume an
IndexedFold
.
type Accessing p m s a = p a ( Const m a) -> s -> Const m s Source #
This is a convenient alias used when consuming (indexed) getters and (indexed) folds in a highly general fashion.
Building Getters
to :: ( Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a Source #
ito :: ( Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a Source #
ito
:: (s -> (i, a)) ->IndexedGetter
i s a
like :: ( Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a Source #
ilike :: ( Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a Source #
ilike
:: i -> a ->IndexedGetter
i s a
Combinators for Getters and Folds
(^.) :: s -> Getting a s a -> a infixl 8 Source #
View the value pointed to by a
Getter
or
Lens
or the
result of folding over all the results of a
Fold
or
Traversal
that points at a monoidal values.
This is the same operation as
view
with the arguments flipped.
The fixity and semantics are such that subsequent field accesses can be
performed with (
.
).
>>>
(a,b)^._2
b
>>>
("hello","world")^._2
"world"
>>>
import Data.Complex
>>>
((0, 1 :+ 2), 3)^._1._2.to magnitude
2.23606797749979
(^.
) :: s ->Getter
s a -> a (^.
) ::Monoid
m => s ->Fold
s m -> m (^.
) :: s ->Iso'
s a -> a (^.
) :: s ->Lens'
s a -> a (^.
) ::Monoid
m => s ->Traversal'
s m -> m
view :: MonadReader s m => Getting a s a -> m a Source #
View the value pointed to by a
Getter
,
Iso
or
Lens
or the result of folding over all the results of a
Fold
or
Traversal
that points
at a monoidal value.
view
.
to
≡id
>>>
view (to f) a
f a
>>>
view _2 (1,"hello")
"hello"
>>>
view (to succ) 5
6
>>>
view (_2._1) ("hello",("world","!!!"))
"world"
As
view
is commonly used to access the target of a
Getter
or obtain a monoidal summary of the targets of a
Fold
,
It may be useful to think of it as having one of these more restricted signatures:
view
::Getter
s a -> s -> aview
::Monoid
m =>Fold
s m -> s -> mview
::Iso'
s a -> s -> aview
::Lens'
s a -> s -> aview
::Monoid
m =>Traversal'
s m -> s -> m
In a more general setting, such as when working with a
Monad
transformer stack you can use:
view
::MonadReader
s m =>Getter
s a -> m aview
:: (MonadReader
s m,Monoid
a) =>Fold
s a -> m aview
::MonadReader
s m =>Iso'
s a -> m aview
::MonadReader
s m =>Lens'
s a -> m aview
:: (MonadReader
s m,Monoid
a) =>Traversal'
s a -> m a
views :: MonadReader s m => LensLike' ( Const r) s a -> (a -> r) -> m r Source #
View a function of the value pointed to by a
Getter
or
Lens
or the result of
folding over the result of mapping the targets of a
Fold
or
Traversal
.
views
l f ≡view
(l.
to
f)
>>>
views (to f) g a
g (f a)
>>>
views _2 length (1,"hello")
5
As
views
is commonly used to access the target of a
Getter
or obtain a monoidal summary of the targets of a
Fold
,
It may be useful to think of it as having one of these more restricted signatures:
views
::Getter
s a -> (a -> r) -> s -> rviews
::Monoid
m =>Fold
s a -> (a -> m) -> s -> mviews
::Iso'
s a -> (a -> r) -> s -> rviews
::Lens'
s a -> (a -> r) -> s -> rviews
::Monoid
m =>Traversal'
s a -> (a -> m) -> s -> m
In a more general setting, such as when working with a
Monad
transformer stack you can use:
views
::MonadReader
s m =>Getter
s a -> (a -> r) -> m rviews
:: (MonadReader
s m,Monoid
r) =>Fold
s a -> (a -> r) -> m rviews
::MonadReader
s m =>Iso'
s a -> (a -> r) -> m rviews
::MonadReader
s m =>Lens'
s a -> (a -> r) -> m rviews
:: (MonadReader
s m,Monoid
r) =>Traversal'
s a -> (a -> r) -> m r
views
::MonadReader
s m =>Getting
r s a -> (a -> r) -> m r
use :: MonadState s m => Getting a s a -> m a Source #
Use the target of a
Lens
,
Iso
, or
Getter
in the current state, or use a summary of a
Fold
or
Traversal
that points
to a monoidal value.
>>>
evalState (use _1) (a,b)
a
>>>
evalState (use _1) ("hello","world")
"hello"
use
::MonadState
s m =>Getter
s a -> m ause
:: (MonadState
s m,Monoid
r) =>Fold
s r -> m ruse
::MonadState
s m =>Iso'
s a -> m ause
::MonadState
s m =>Lens'
s a -> m ause
:: (MonadState
s m,Monoid
r) =>Traversal'
s r -> m r
uses :: MonadState s m => LensLike' ( Const r) s a -> (a -> r) -> m r Source #
Use the target of a
Lens
,
Iso
or
Getter
in the current state, or use a summary of a
Fold
or
Traversal
that
points to a monoidal value.
>>>
evalState (uses _1 length) ("hello","world")
5
uses
::MonadState
s m =>Getter
s a -> (a -> r) -> m ruses
:: (MonadState
s m,Monoid
r) =>Fold
s a -> (a -> r) -> m ruses
::MonadState
s m =>Lens'
s a -> (a -> r) -> m ruses
::MonadState
s m =>Iso'
s a -> (a -> r) -> m ruses
:: (MonadState
s m,Monoid
r) =>Traversal'
s a -> (a -> r) -> m r
uses
::MonadState
s m =>Getting
r s t a b -> (a -> r) -> m r
listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u) Source #
This is a generalized form of
listen
that only extracts the portion of
the log that is focused on by a
Getter
. If given a
Fold
or a
Traversal
then a monoidal summary of the parts of the log that are visited will be
returned.
listening
::MonadWriter
w m =>Getter
w u -> m a -> m (a, u)listening
::MonadWriter
w m =>Lens'
w u -> m a -> m (a, u)listening
::MonadWriter
w m =>Iso'
w u -> m a -> m (a, u)listening
:: (MonadWriter
w m,Monoid
u) =>Fold
w u -> m a -> m (a, u)listening
:: (MonadWriter
w m,Monoid
u) =>Traversal'
w u -> m a -> m (a, u)listening
:: (MonadWriter
w m,Monoid
u) =>Prism'
w u -> m a -> m (a, u)
listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v) Source #
This is a generalized form of
listen
that only extracts the portion of
the log that is focused on by a
Getter
. If given a
Fold
or a
Traversal
then a monoidal summary of the parts of the log that are visited will be
returned.
listenings
::MonadWriter
w m =>Getter
w u -> (u -> v) -> m a -> m (a, v)listenings
::MonadWriter
w m =>Lens'
w u -> (u -> v) -> m a -> m (a, v)listenings
::MonadWriter
w m =>Iso'
w u -> (u -> v) -> m a -> m (a, v)listenings
:: (MonadWriter
w m,Monoid
v) =>Fold
w u -> (u -> v) -> m a -> m (a, v)listenings
:: (MonadWriter
w m,Monoid
v) =>Traversal'
w u -> (u -> v) -> m a -> m (a, v)listenings
:: (MonadWriter
w m,Monoid
v) =>Prism'
w u -> (u -> v) -> m a -> m (a, v)
Indexed Getters
Indexed Getter Combinators
(^@.) :: s -> IndexedGetting i (i, a) s a -> (i, a) infixl 8 Source #
View the index and value of an
IndexedGetter
or
IndexedLens
.
This is the same operation as
iview
with the arguments flipped.
The fixity and semantics are such that subsequent field accesses can be
performed with (
.
).
(^@.
) :: s ->IndexedGetter
i s a -> (i, a) (^@.
) :: s ->IndexedLens'
i s a -> (i, a)
The result probably doesn't have much meaning when applied to an
IndexedFold
.
iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a) Source #
View the index and value of an
IndexedGetter
into the current environment as a pair.
When applied to an
IndexedFold
the result will most likely be a nonsensical monoidal summary of
the indices tupled with a monoidal summary of the values and probably not whatever it is you wanted.
iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r Source #
View a function of the index and value of an
IndexedGetter
into the current environment.
When applied to an
IndexedFold
the result will be a monoidal summary instead of a single answer.
iviews
≡ifoldMapOf
iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a) Source #
Use the index and value of an
IndexedGetter
into the current state as a pair.
When applied to an
IndexedFold
the result will most likely be a nonsensical monoidal summary of
the indices tupled with a monoidal summary of the values and probably not whatever it is you wanted.
iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r Source #
Use a function of the index and value of an
IndexedGetter
into the current state.
When applied to an
IndexedFold
the result will be a monoidal summary instead of a single answer.
ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u)) Source #
This is a generalized form of
listen
that only extracts the portion of
the log that is focused on by a
Getter
. If given a
Fold
or a
Traversal
then a monoidal summary of the parts of the log that are visited will be
returned.
ilistening
::MonadWriter
w m =>IndexedGetter
i w u -> m a -> m (a, (i, u))ilistening
::MonadWriter
w m =>IndexedLens'
i w u -> m a -> m (a, (i, u))ilistening
:: (MonadWriter
w m,Monoid
u) =>IndexedFold
i w u -> m a -> m (a, (i, u))ilistening
:: (MonadWriter
w m,Monoid
u) =>IndexedTraversal'
i w u -> m a -> m (a, (i, u))
ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v) Source #
This is a generalized form of
listen
that only extracts the portion of
the log that is focused on by a
Getter
. If given a
Fold
or a
Traversal
then a monoidal summary of the parts of the log that are visited will be
returned.
ilistenings
::MonadWriter
w m =>IndexedGetter
w u -> (i -> u -> v) -> m a -> m (a, v)ilistenings
::MonadWriter
w m =>IndexedLens'
w u -> (i -> u -> v) -> m a -> m (a, v)ilistenings
:: (MonadWriter
w m,Monoid
v) =>IndexedFold
w u -> (i -> u -> v) -> m a -> m (a, v)ilistenings
:: (MonadWriter
w m,Monoid
v) =>IndexedTraversal'
w u -> (i -> u -> v) -> m a -> m (a, v)
Implementation Details
class Contravariant (f :: Type -> Type ) where Source #
The class of contravariant functors.
Whereas in Haskell, one can think of a
Functor
as containing or producing
values, a contravariant functor is a functor that can be thought of as
consuming
values.
As an example, consider the type of predicate functions
a -> Bool
. One
such predicate might be
negative x = x < 0
, which
classifies integers as to whether they are negative. However, given this
predicate, we can re-use it in other situations, providing we have a way to
map values
to
integers. For instance, we can use the
negative
predicate
on a person's bank balance to work out if they are currently overdrawn:
newtype Predicate a = Predicate { getPredicate :: a -> Bool } instance Contravariant Predicate where contramap f (Predicate p) = Predicate (p . f) | `- First, map the input... `----- then apply the predicate. overdrawn :: Predicate Person overdrawn = contramap personBankBalance negative
Any instance should be subject to the following laws:
Note, that the second law follows from the free theorem of the type of
contramap
and the first law, so you need only check that the former
condition holds.
Minimal complete definition
Instances
getting :: ( Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a Source #
Coerce a
Getter
-compatible
Optical
to an
Optical'
. This
is useful when using a
Traversal
that is not simple as a
Getter
or a
Fold
.
getting
::Traversal
s t a b ->Fold
s agetting
::Lens
s t a b ->Getter
s agetting
::IndexedTraversal
i s t a b ->IndexedFold
i s agetting
::IndexedLens
i s t a b ->IndexedGetter
i s a
newtype Const a (b :: k) Source #
The
Const
functor.
Instances
Generic1 ( Const a :: k -> Type ) |
Since: base-4.9.0.0 |
FunctorWithIndex Void ( Const e :: Type -> Type ) | |
FoldableWithIndex Void ( Const e :: Type -> Type ) | |
Defined in WithIndex Methods ifoldMap :: Monoid m => ( Void -> a -> m) -> Const e a -> m Source # ifoldMap' :: Monoid m => ( Void -> a -> m) -> Const e a -> m Source # ifoldr :: ( Void -> a -> b -> b) -> b -> Const e a -> b Source # ifoldl :: ( Void -> b -> a -> b) -> b -> Const e a -> b Source # ifoldr' :: ( Void -> a -> b -> b) -> b -> Const e a -> b Source # ifoldl' :: ( Void -> b -> a -> b) -> b -> Const e a -> b Source # |
|
TraversableWithIndex Void ( Const e :: Type -> Type ) | |
Unbox a => Vector Vector ( Const a b) | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Const a b) -> m ( Vector ( Const a b)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Const a b) -> m ( Mutable Vector ( PrimState m) ( Const a b)) Source # basicLength :: Vector ( Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Const a b) -> Vector ( Const a b) Source # basicUnsafeIndexM :: Monad m => Vector ( Const a b) -> Int -> m ( Const a b) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Const a b) -> Vector ( Const a b) -> m () Source # elemseq :: Vector ( Const a b) -> Const a b -> b0 -> b0 Source # |
|
Unbox a => MVector MVector ( Const a b) | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Const a b) -> MVector s ( Const a b) Source # basicOverlaps :: MVector s ( Const a b) -> MVector s ( Const a b) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Const a b)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m ( MVector ( PrimState m) ( Const a b)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Int -> m ( Const a b) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Int -> Const a b -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Const a b -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> MVector ( PrimState m) ( Const a b) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> MVector ( PrimState m) ( Const a b) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Const a b) -> Int -> m ( MVector ( PrimState m) ( Const a b)) Source # |
|
Bifunctor ( Const :: Type -> Type -> Type ) |
Since: base-4.8.0.0 |
Bitraversable ( Const :: Type -> Type -> Type ) |
Since: base-4.10.0.0 |
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f ( Const c d) Source # |
|
Bifoldable ( Const :: Type -> Type -> Type ) |
Since: base-4.10.0.0 |
Defined in Data.Bifoldable |
|
Eq2 ( Const :: Type -> Type -> Type ) |
Since: base-4.9.0.0 |
Ord2 ( Const :: Type -> Type -> Type ) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Classes |
|
Read2 ( Const :: Type -> Type -> Type ) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: ( Int -> ReadS a) -> ReadS [a] -> ( Int -> ReadS b) -> ReadS [b] -> Int -> ReadS ( Const a b) Source # liftReadList2 :: ( Int -> ReadS a) -> ReadS [a] -> ( Int -> ReadS b) -> ReadS [b] -> ReadS [ Const a b] Source # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec ( Const a b) Source # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [ Const a b] Source # |
|
Show2 ( Const :: Type -> Type -> Type ) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Classes |
|
Biapplicative ( Const :: Type -> Type -> Type ) | |
NFData2 ( Const :: Type -> Type -> Type ) |
Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq |
|
Hashable2 ( Const :: Type -> Type -> Type ) | |
Bitraversable1 ( Const :: Type -> Type -> Type ) | |
Defined in Data.Semigroup.Traversable.Class |
|
Biapply ( Const :: Type -> Type -> Type ) | |
Bifoldable1 ( Const :: Type -> Type -> Type ) | |
Semigroupoid ( Const :: Type -> Type -> Type ) | |
Functor ( Const m :: Type -> Type ) |
Since: base-2.1 |
Monoid m => Applicative ( Const m :: Type -> Type ) |
Since: base-2.0.1 |
Defined in Data.Functor.Const |
|
Foldable ( Const m :: Type -> Type ) |
Since: base-4.7.0.0 |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 Source # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldr :: (a -> b -> b) -> b -> Const m a -> b Source # foldr' :: (a -> b -> b) -> b -> Const m a -> b Source # foldl :: (b -> a -> b) -> b -> Const m a -> b Source # foldl' :: (b -> a -> b) -> b -> Const m a -> b Source # foldr1 :: (a -> a -> a) -> Const m a -> a Source # foldl1 :: (a -> a -> a) -> Const m a -> a Source # toList :: Const m a -> [a] Source # null :: Const m a -> Bool Source # length :: Const m a -> Int Source # elem :: Eq a => a -> Const m a -> Bool Source # maximum :: Ord a => Const m a -> a Source # minimum :: Ord a => Const m a -> a Source # |
|
Traversable ( Const m :: Type -> Type ) |
Since: base-4.7.0.0 |
Defined in Data.Traversable |
|
Contravariant ( Const a :: Type -> Type ) | |
Eq a => Eq1 ( Const a :: Type -> Type ) |
Since: base-4.9.0.0 |
Ord a => Ord1 ( Const a :: Type -> Type ) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Classes |
|
Read a => Read1 ( Const a :: Type -> Type ) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Classes Methods liftReadsPrec :: ( Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS ( Const a a0) Source # liftReadList :: ( Int -> ReadS a0) -> ReadS [a0] -> ReadS [ Const a a0] Source # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec ( Const a a0) Source # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [ Const a a0] Source # |
|
Show a => Show1 ( Const a :: Type -> Type ) |
Since: base-4.9.0.0 |
NFData a => NFData1 ( Const a :: Type -> Type ) |
Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq |
|
Hashable a => Hashable1 ( Const a :: Type -> Type ) | |
Defined in Data.Hashable.Class |
|
Semigroup m => Apply ( Const m :: Type -> Type ) |
A
|
ComonadCofree ( Const b :: Type -> Type ) ( (,) b) | |
Defined in Control.Comonad.Cofree.Class |
|
Sieve ( Forget r :: Type -> Type -> Type ) ( Const r :: Type -> Type ) | |
Bounded a => Bounded ( Const a b) |
Since: base-4.9.0.0 |
Enum a => Enum ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b Source # pred :: Const a b -> Const a b Source # toEnum :: Int -> Const a b Source # fromEnum :: Const a b -> Int Source # enumFrom :: Const a b -> [ Const a b] Source # enumFromThen :: Const a b -> Const a b -> [ Const a b] Source # enumFromTo :: Const a b -> Const a b -> [ Const a b] Source # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [ Const a b] Source # |
|
Eq a => Eq ( Const a b) |
Since: base-4.9.0.0 |
Floating a => Floating ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods exp :: Const a b -> Const a b Source # log :: Const a b -> Const a b Source # sqrt :: Const a b -> Const a b Source # (**) :: Const a b -> Const a b -> Const a b Source # logBase :: Const a b -> Const a b -> Const a b Source # sin :: Const a b -> Const a b Source # cos :: Const a b -> Const a b Source # tan :: Const a b -> Const a b Source # asin :: Const a b -> Const a b Source # acos :: Const a b -> Const a b Source # atan :: Const a b -> Const a b Source # sinh :: Const a b -> Const a b Source # cosh :: Const a b -> Const a b Source # tanh :: Const a b -> Const a b Source # asinh :: Const a b -> Const a b Source # acosh :: Const a b -> Const a b Source # atanh :: Const a b -> Const a b Source # log1p :: Const a b -> Const a b Source # expm1 :: Const a b -> Const a b Source # |
|
Fractional a => Fractional ( Const a b) |
Since: base-4.9.0.0 |
Integral a => Integral ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b Source # rem :: Const a b -> Const a b -> Const a b Source # div :: Const a b -> Const a b -> Const a b Source # mod :: Const a b -> Const a b -> Const a b Source # quotRem :: Const a b -> Const a b -> ( Const a b, Const a b) Source # divMod :: Const a b -> Const a b -> ( Const a b, Const a b) Source # |
|
( Typeable k, Data a, Typeable b) => Data ( Const a b) |
Since: base-4.10.0.0 |
Defined in Data.Data Methods gfoldl :: ( forall d b0. Data d => c (d -> b0) -> d -> c b0) -> ( forall g. g -> c g) -> Const a b -> c ( Const a b) Source # gunfold :: ( forall b0 r. Data b0 => c (b0 -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Const a b) Source # toConstr :: Const a b -> Constr Source # dataTypeOf :: Const a b -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Const a b)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Const a b)) Source # gmapT :: ( forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Const a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Const a b -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Const a b -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Const a b -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Const a b -> m ( Const a b) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Const a b -> m ( Const a b) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Const a b -> m ( Const a b) Source # |
|
Num a => Num ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b Source # (-) :: Const a b -> Const a b -> Const a b Source # (*) :: Const a b -> Const a b -> Const a b Source # negate :: Const a b -> Const a b Source # abs :: Const a b -> Const a b Source # signum :: Const a b -> Const a b Source # fromInteger :: Integer -> Const a b Source # |
|
Ord a => Ord ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering Source # (<) :: Const a b -> Const a b -> Bool Source # (<=) :: Const a b -> Const a b -> Bool Source # (>) :: Const a b -> Const a b -> Bool Source # (>=) :: Const a b -> Const a b -> Bool Source # |
|
Read a => Read ( Const a b) |
This instance would be equivalent to the derived instances of the
Since: base-4.8.0.0 |
Real a => Real ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational Source # |
|
RealFloat a => RealFloat ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer Source # floatDigits :: Const a b -> Int Source # floatRange :: Const a b -> ( Int , Int ) Source # decodeFloat :: Const a b -> ( Integer , Int ) Source # encodeFloat :: Integer -> Int -> Const a b Source # exponent :: Const a b -> Int Source # significand :: Const a b -> Const a b Source # scaleFloat :: Int -> Const a b -> Const a b Source # isNaN :: Const a b -> Bool Source # isInfinite :: Const a b -> Bool Source # isDenormalized :: Const a b -> Bool Source # isNegativeZero :: Const a b -> Bool Source # |
|
RealFrac a => RealFrac ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const |
|
Show a => Show ( Const a b) |
This instance would be equivalent to the derived instances of the
Since: base-4.8.0.0 |
Ix a => Ix ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods range :: ( Const a b, Const a b) -> [ Const a b] Source # index :: ( Const a b, Const a b) -> Const a b -> Int Source # unsafeIndex :: ( Const a b, Const a b) -> Const a b -> Int Source # inRange :: ( Const a b, Const a b) -> Const a b -> Bool Source # |
|
Generic ( Const a b) |
Since: base-4.9.0.0 |
Semigroup a => Semigroup ( Const a b) |
Since: base-4.9.0.0 |
Monoid a => Monoid ( Const a b) |
Since: base-4.9.0.0 |
Storable a => Storable ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int Source # alignment :: Const a b -> Int Source # peekElemOff :: Ptr ( Const a b) -> Int -> IO ( Const a b) Source # pokeElemOff :: Ptr ( Const a b) -> Int -> Const a b -> IO () Source # peekByteOff :: Ptr b0 -> Int -> IO ( Const a b) Source # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () Source # |
|
Bits a => Bits ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b Source # (.|.) :: Const a b -> Const a b -> Const a b Source # xor :: Const a b -> Const a b -> Const a b Source # complement :: Const a b -> Const a b Source # shift :: Const a b -> Int -> Const a b Source # rotate :: Const a b -> Int -> Const a b Source # zeroBits :: Const a b Source # bit :: Int -> Const a b Source # setBit :: Const a b -> Int -> Const a b Source # clearBit :: Const a b -> Int -> Const a b Source # complementBit :: Const a b -> Int -> Const a b Source # testBit :: Const a b -> Int -> Bool Source # bitSizeMaybe :: Const a b -> Maybe Int Source # bitSize :: Const a b -> Int Source # isSigned :: Const a b -> Bool Source # shiftL :: Const a b -> Int -> Const a b Source # unsafeShiftL :: Const a b -> Int -> Const a b Source # shiftR :: Const a b -> Int -> Const a b Source # unsafeShiftR :: Const a b -> Int -> Const a b Source # rotateL :: Const a b -> Int -> Const a b Source # |
|
FiniteBits a => FiniteBits ( Const a b) |
Since: base-4.9.0.0 |
Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int Source # countLeadingZeros :: Const a b -> Int Source # countTrailingZeros :: Const a b -> Int Source # |
|
NFData a => NFData ( Const a b) |
Since: deepseq-1.4.0.0 |
Defined in Control.DeepSeq |
|
Hashable a => Hashable ( Const a b) | |
Prim a => Prim ( Const a b) |
Since: primitive-0.6.5.0 |
Defined in Data.Primitive.Types Methods sizeOf# :: Const a b -> Int# Source # alignment# :: Const a b -> Int# Source # indexByteArray# :: ByteArray# -> Int# -> Const a b Source # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Const a b #) Source # writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s Source # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s Source # indexOffAddr# :: Addr# -> Int# -> Const a b Source # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Const a b #) Source # writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s Source # setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s Source # |
|
Unbox a => Unbox ( Const a b) | |
Defined in Data.Vector.Unboxed.Base |
|
Wrapped ( Const a x) Source # | |
t ~ Const a' x' => Rewrapped ( Const a x) t Source # | |
Defined in Control.Lens.Wrapped |
|
type Rep1 ( Const a :: k -> Type ) | |
Defined in Data.Functor.Const |
|
newtype MVector s ( Const a b) | |
Defined in Data.Vector.Unboxed.Base |
|
type Rep ( Const a b) | |
Defined in Data.Functor.Const |
|
newtype Vector ( Const a b) | |
Defined in Data.Vector.Unboxed.Base |
|
type Unwrapped ( Const a x) Source # | |
Defined in Control.Lens.Wrapped |