| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.Functor.Linear
Description
The data functor hierarchy
This module defines the data functor library. Unlike in the case of non-linear, unrestricted, functors, there is a split between data functors, which represent containers, and control functors which represent effects. Please read this blog post. For more details, see Control.Functor.Linear.
- Linear data functors should be thought of as containers of data.
- Linear data applicative functors should be thought of as containers that can be zipped.
- Linear data traversable functors should be thought of as containers which store a finite number of values.
This module also defines genericTraverse for types implementing
Generic1.
Synopsis
- class Functor (f :: Type -> Type) where
- fmap :: (a %1 -> b) -> f a %1 -> f b
- (<$>) :: Functor f => (a %1 -> b) -> f a %1 -> f b
- (<$) :: (Functor f, Consumable b) => a -> f b %1 -> f a
- void :: (Functor f, Consumable a) => f a %1 -> f ()
- class Functor f => Applicative (f :: Type -> Type) where
- newtype Const a (b :: k) = Const {
- getConst :: a
- class Functor t => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a %1 -> f b) -> t a %1 -> f (t b)
- sequence :: Applicative f => t (f a) %1 -> f (t a)
- genericTraverse :: (Generic1 t, GTraversable (Rep1 t), Applicative f) => (a %1 -> f b) -> t a %1 -> f (t b)
- class GTraversable (t :: Type -> Type)
- mapM :: (Traversable t, Monad m) => (a %1 -> m b) -> t a %1 -> m (t b)
- sequenceA :: (Traversable t, Applicative f) => t (f a) %1 -> f (t a)
- for :: (Traversable t, Applicative f) => t a %1 -> (a %1 -> f b) -> f (t b)
- forM :: (Traversable t, Monad m) => t a %1 -> (a %1 -> m b) -> m (t b)
- mapAccumL :: Traversable t => (a %1 -> b %1 -> (a, c)) -> a %1 -> t b %1 -> (a, t c)
- mapAccumR :: Traversable t => (a %1 -> b %1 -> (a, c)) -> a %1 -> t b %1 -> (a, t c)
Data Functor Hierarchy
class Functor (f :: Type -> Type) where Source #
Linear Data Functors should be thought of as containers holding values of
type a over which you are able to apply a linear function of type a %1->
b on each value of type a in the functor and consume a given functor
of type f a.
Instances
(<$) :: (Functor f, Consumable b) => a -> f b %1 -> f a infixl 4 Source #
Replace all occurances of b with the given a
and consume the functor f b.
void :: (Functor f, Consumable a) => f a %1 -> f () Source #
Discard a consumable value stored in a data functor.
class Functor f => Applicative (f :: Type -> Type) where Source #
Data Applicative-s can be seen as containers which can be zipped
together. A prime example of data Applicative are vectors of known length
(ZipLists would be, if it were not for the fact that zipping them together
drops values, which we are not allowed to do in a linear container).
In fact, an applicative functor is precisely a functor equipped with (pure
and) liftA2 :: (a %1-> b %1-> c) -> f a %1-> f b %1-> f c. In the case where
f = [], the signature of liftA2 would specialise to that of zipWith.
Intuitively, the type of liftA2 means that Applicatives can be seen as
containers whose "number" of elements is known at compile-time. This
includes vectors of known length but excludes Maybe, since this may
contain either zero or one value. Similarly, ((->) r) forms a Data
Applicative, since this is a (possibly infinitary) container indexed by
r, while lists do not, since they may contain any number of elements.
Remarks for the mathematically inclined
An Applicative is, as in the restricted case, a lax monoidal endofunctor of
the category of linear types. That is, it is equipped with
- a (linear) function
() %1-> f () - a (linear) natural transformation
(f a, f b) %1-> f (a, b)
It is a simple exercise to verify that these are equivalent to the definition
of Applicative. Hence that the choice of linearity of the various arrow is
indeed natural.
Methods
(<*>) :: f (a %1 -> b) %1 -> f a %1 -> f b infixl 4 Source #
liftA2 :: (a %1 -> b %1 -> c) -> f a %1 -> f b %1 -> f c Source #
Instances
The Const functor.
Examples
>>>fmap (++ "World") (Const "Hello")Const "Hello"
Because we ignore the second type parameter to Const,
the Applicative instance, which has
(<*>) :: Monoid m => Const m (a -> b) -> Const m a -> Const m bMonoid m => m -> m -> m, which is (<>)
>>>Const [1, 2, 3] <*> Const [4, 5, 6]Const [1,2,3,4,5,6]
Instances
| Strong Either Void (CoKleisli (Const x :: Type -> Type)) Source # | |||||
| Generic1 (Const a :: k -> Type) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
| Unbox a => Vector Vector (Const a b) | |||||
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Const a b) -> ST s (Vector (Const a b)) basicUnsafeThaw :: Vector (Const a b) -> ST s (Mutable Vector s (Const a b)) basicLength :: Vector (Const a b) -> Int basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) basicUnsafeIndexM :: Vector (Const a b) -> Int -> Box (Const a b) basicUnsafeCopy :: Mutable Vector s (Const a b) -> Vector (Const a b) -> ST s () | |||||
| Unbox a => MVector MVector (Const a b) | |||||
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Const a b) -> Int basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b) basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool basicUnsafeNew :: Int -> ST s (MVector s (Const a b)) basicInitialize :: MVector s (Const a b) -> ST s () basicUnsafeReplicate :: Int -> Const a b -> ST s (MVector s (Const a b)) basicUnsafeRead :: MVector s (Const a b) -> Int -> ST s (Const a b) basicUnsafeWrite :: MVector s (Const a b) -> Int -> Const a b -> ST s () basicClear :: MVector s (Const a b) -> ST s () basicSet :: MVector s (Const a b) -> Const a b -> ST s () basicUnsafeCopy :: MVector s (Const a b) -> MVector s (Const a b) -> ST s () basicUnsafeMove :: MVector s (Const a b) -> MVector s (Const a b) -> ST s () basicUnsafeGrow :: MVector s (Const a b) -> Int -> ST s (MVector s (Const a b)) | |||||
| Bifoldable (Const :: Type -> Type -> Type) | Since: base-4.10.0.0 | ||||
| Bifoldable1 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Bifoldable1 | |||||
| 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) # | |||||
| 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) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] # | |||||
| Show2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0 | ||||
| NFData2 (Const :: Type -> Type -> Type) | Since: deepseq-1.4.3.0 | ||||
Defined in Control.DeepSeq | |||||
| Hashable2 (Const :: Type -> Type -> Type) | |||||
Defined in Data.Hashable.Class | |||||
| 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) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] # | |||||
| Show a => Show1 (Const a :: Type -> Type) | Since: base-4.9.0.0 | ||||
| Contravariant (Const a :: Type -> Type) | |||||
| NFData a => NFData1 (Const a :: Type -> Type) | Since: deepseq-1.4.3.0 | ||||
Defined in Control.DeepSeq | |||||
| Monoid m => Applicative (Const m :: Type -> Type) | Since: base-2.0.1 | ||||
| Functor (Const m :: Type -> Type) | Since: base-2.1 | ||||
| Foldable (Const m :: Type -> Type) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |||||
| Traversable (Const m :: Type -> Type) | Since: base-4.7.0.0 | ||||
Defined in GHC.Internal.Data.Traversable | |||||
| Hashable a => Hashable1 (Const a :: Type -> Type) | |||||
Defined in Data.Hashable.Class | |||||
| Monoid x => Applicative (Const x :: Type -> Type) Source # | |||||
| Functor (Const x :: Type -> Type) Source # | |||||
| Traversable (Const a :: Type -> Type) Source # | |||||
Defined in Data.Functor.Linear.Internal.Traversable | |||||
| NFData a => NFData (Const a b) | Since: deepseq-1.4.0.0 | ||||
Defined in Control.DeepSeq | |||||
| Monoid a => Monoid (Const a b) | Since: base-4.9.0.0 | ||||
| Semigroup a => Semigroup (Const a b) | Since: base-4.9.0.0 | ||||
| Bits a => Bits (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # | |||||
| FiniteBits a => FiniteBits (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int # | |||||
| IsString a => IsString (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.String Methods fromString :: String -> Const a b # | |||||
| 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 GHC.Internal.Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |||||
| Floating a => Floating (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # | |||||
| RealFloat a => RealFloat (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # | |||||
| Storable a => Storable (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Generic (Const a b) | |||||
Defined in GHC.Internal.Data.Functor.Const Associated Types
| |||||
| Ix a => Ix (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] # index :: (Const a b, Const a b) -> Const a b -> Int # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int # inRange :: (Const a b, Const a b) -> Const a b -> Bool # rangeSize :: (Const a b, Const a b) -> Int # unsafeRangeSize :: (Const a b, Const a b) -> Int # | |||||
| Num a => Num (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| Read a => Read (Const a b) | This instance would be equivalent to the derived instances of the
Since: base-4.8.0.0 | ||||
| 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 GHC.Internal.Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # | |||||
| Real a => Real (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const Methods toRational :: Const a b -> Rational # | |||||
| RealFrac a => RealFrac (Const a b) | Since: base-4.9.0.0 | ||||
| Show a => Show (Const a b) | This instance would be equivalent to the derived instances of the
Since: base-4.8.0.0 | ||||
| Eq a => Eq (Const a b) | Since: base-4.9.0.0 | ||||
| Ord a => Ord (Const a b) | Since: base-4.9.0.0 | ||||
| Hashable a => Hashable (Const a b) | |||||
Defined in Data.Hashable.Class | |||||
| Monoid a => Monoid (Const a b) Source # | |||||
Defined in Data.Monoid.Linear.Internal.Monoid | |||||
| Semigroup a => Semigroup (Const a b) Source # | |||||
| Prim a => Prim (Const a b) | Since: primitive-0.6.5.0 | ||||
Defined in Data.Primitive.Types Methods sizeOfType# :: Proxy (Const a b) -> Int# # sizeOf# :: Const a b -> Int# # alignmentOfType# :: Proxy (Const a b) -> Int# # alignment# :: Const a b -> Int# # indexByteArray# :: ByteArray# -> Int# -> Const a b # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Const a b #) # writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Const a b # readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Const a b #) # writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s # | |||||
| Unbox a => Unbox (Const a b) | |||||
Defined in Data.Vector.Unboxed.Base | |||||
| type Rep1 (Const a :: k -> Type) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| type Rep1 (Const a :: k -> Type) | |||||
Defined in Generics.Linear.Instances.Base | |||||
| newtype MVector s (Const a b) | |||||
Defined in Data.Vector.Unboxed.Base | |||||
| type Rep (Const a b) | Since: base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Functor.Const | |||||
| type Rep (Const a b) | |||||
Defined in Generics.Linear.Instances.Base | |||||
| newtype Vector (Const a b) | |||||
Defined in Data.Vector.Unboxed.Base | |||||
Linear traversable hierarchy
class Functor t => Traversable (t :: Type -> Type) where Source #
A linear data traversible is a functor of type t a where you can apply a
linear effectful action of type a %1-> f b on each value of type a and
compose this to perform an action on the whole functor, resulting in a value
of type f (t b).
To learn more about Traversable, see here:
- "Applicative Programming with Effects", by Conor McBride and Ross Paterson, Journal of Functional Programming 18:1 (2008) 1-13, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html.
- "The Essence of the Iterator Pattern", by Jeremy Gibbons and Bruno Oliveira, in Mathematically-Structured Functional Programming, 2006, online at http://web.comlab.ox.ac.uk/oucl/work/jeremy.gibbons/publications/#iterator.
- "An Investigation of the Laws of Traversals", by Mauro Jaskelioff and Ondrej Rypacek, in Mathematically-Structured Functional Programming, 2012, online at http://arxiv.org/pdf/1202.2919.
Methods
traverse :: Applicative f => (a %1 -> f b) -> t a %1 -> f (t b) Source #
sequence :: Applicative f => t (f a) %1 -> f (t a) Source #
Instances
genericTraverse :: (Generic1 t, GTraversable (Rep1 t), Applicative f) => (a %1 -> f b) -> t a %1 -> f (t b) Source #
Implementation of traverse for types which derive
(linear) Generic1.
### Performance note
At present, this function does not perform well for recursive types like lists; it will not specialize to either
### Example
data T $(deriveGeneric1 ''T) instance Traversable T where traverse = genericTraverse
Note that, contrary to many other classes in linear-base, we can't define
`Traversable T` using deriving via, because the
role
of t, in the type of traverse, is nominal.
class GTraversable (t :: Type -> Type) Source #
This type class derives the definition of genericTraverse by induction on
the generic representation of a type.
Minimal complete definition
gtraverse
Instances
| GTraversable Par1 Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> Par1 a %1 -> Curried (Yoneda f) (Yoneda f) (Par1 b) | |
| GTraversable (U1 :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> U1 a %1 -> Curried (Yoneda f) (Yoneda f) (U1 b) | |
| GTraversable (UAddr :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> UAddr a %1 -> Curried (Yoneda f) (Yoneda f) (UAddr b) | |
| GTraversable (UChar :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> UChar a %1 -> Curried (Yoneda f) (Yoneda f) (UChar b) | |
| GTraversable (UDouble :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> UDouble a %1 -> Curried (Yoneda f) (Yoneda f) (UDouble b) | |
| GTraversable (UFloat :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> UFloat a %1 -> Curried (Yoneda f) (Yoneda f) (UFloat b) | |
| GTraversable (UInt :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> UInt a %1 -> Curried (Yoneda f) (Yoneda f) (UInt b) | |
| GTraversable (UWord :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> UWord a %1 -> Curried (Yoneda f) (Yoneda f) (UWord b) | |
| GTraversable (V1 :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> V1 a %1 -> Curried (Yoneda f) (Yoneda f) (V1 b) | |
| (GTraversable f, GTraversable g) => GTraversable (f :*: g) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f0 => (a %1 -> f0 b) -> (f :*: g) a %1 -> Curried (Yoneda f0) (Yoneda f0) ((f :*: g) b) | |
| (GTraversable f, GTraversable g) => GTraversable (f :+: g) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f0 => (a %1 -> f0 b) -> (f :+: g) a %1 -> Curried (Yoneda f0) (Yoneda f0) ((f :+: g) b) | |
| GTraversable (K1 i c :: Type -> Type) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> K1 i c a %1 -> Curried (Yoneda f) (Yoneda f) (K1 i c b) | |
| (m ~ 'One, GTraversable t) => GTraversable (MP1 m t) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> MP1 m t a %1 -> Curried (Yoneda f) (Yoneda f) (MP1 m t b) | |
| GTraversable t => GTraversable (M1 i c t) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f => (a %1 -> f b) -> M1 i c t a %1 -> Curried (Yoneda f) (Yoneda f) (M1 i c t b) | |
| (GTraversable f, Traversable g) => GTraversable (f :.: g) Source # | |
Defined in Data.Functor.Linear.Internal.Traversable Methods gtraverse :: Applicative f0 => (a %1 -> f0 b) -> (f :.: g) a %1 -> Curried (Yoneda f0) (Yoneda f0) ((f :.: g) b) | |
mapM :: (Traversable t, Monad m) => (a %1 -> m b) -> t a %1 -> m (t b) Source #
sequenceA :: (Traversable t, Applicative f) => t (f a) %1 -> f (t a) Source #
for :: (Traversable t, Applicative f) => t a %1 -> (a %1 -> f b) -> f (t b) Source #
forM :: (Traversable t, Monad m) => t a %1 -> (a %1 -> m b) -> m (t b) Source #
mapAccumL :: Traversable t => (a %1 -> b %1 -> (a, c)) -> a %1 -> t b %1 -> (a, t c) Source #
mapAccumR :: Traversable t => (a %1 -> b %1 -> (a, c)) -> a %1 -> t b %1 -> (a, t c) Source #