Data.Functor.Apply

Functors

class Functor f where

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

 fmap id  ==  id
 fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO satisfy these laws.

Methods

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

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

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Instances

Functor []

Functor IO

Functor ZipList

Functor Maybe

Functor FingerTree

Functor Digit

Functor Node

Functor Elem

Functor Id

Functor Tree

Functor Seq

Functor ViewL

Functor ViewR

Functor IntMap

Functor Identity

Functor ((->) r)

Functor (Either a)

Functor ((,) a)

Functor (Const m)

Monad m => Functor (WrappedMonad m)

Functor (State s)

Functor (Map k)

Functor m => Functor (IdentityT m)

Functor f => Functor (MaybeApply f)

Functor f => Functor (WrappedApplicative f)

Arrow a => Functor (WrappedArrow a b)

Functor (Cokleisli w a)

(<$>) :: Functor f => (a -> b) -> f a -> f b

An infix synonym for fmap.

($>) :: Functor f => f a -> b -> f b

TODO: move into Data.Functor

FunctorApply - a strong lax semimonoidal endofunctor

class Functor f => FunctorApply f where

A strong lax semi-monoidal endofunctor

Methods

(<.>) :: f (a -> b) -> f a -> f b

(.>) :: f a -> f b -> f b

a .> b = const id $ a . b

(<.) :: f a -> f b -> f a

a . b = const <$ a . b

Instances

FunctorApply []

FunctorApply IO

FunctorApply ZipList

FunctorApply Maybe

FunctorApply Tree

FunctorApply Seq

FunctorApply IntMap

An IntMap is not Applicative, but it is an instance of FunctorApply

FunctorApply Identity

FunctorApply ((->) m)

Semigroup m => FunctorApply ((,) m)

Semigroup m => FunctorApply (Const m)

Monad m => FunctorApply (WrappedMonad m)

Ord k => FunctorApply (Map k)

A Map is not Applicative, but it is an instance of FunctorApply

FunctorApply w => FunctorApply (IdentityT w)

FunctorApply f => FunctorApply (MaybeApply f)

Applicative f => FunctorApply (WrappedApplicative f)

Arrow a => FunctorApply (WrappedArrow a b)

FunctorApply (Cokleisli w a)

(<..>) :: FunctorApply w => w a -> w (a -> b) -> w b

A variant of <.> with the arguments reversed.

liftF2 :: FunctorApply w => (a -> b -> c) -> w a -> w b -> w c

Lift a binary function into a comonad with zipping

liftF3 :: FunctorApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d

Lift a ternary function into a comonad with zipping

Wrappers

newtype WrappedApplicative f a

Wrap an Applicative to be used as a member of FunctorApply

Constructors

WrappedApplicative

Fields

unwrapApplicative :: f a

Instances

Functor f => Functor (WrappedApplicative f)

Applicative f => Applicative (WrappedApplicative f)

Applicative f => FunctorApply (WrappedApplicative f)

newtype MaybeApply f a

Transform a FunctorApply into an Applicative by adding a unit.

Constructors

MaybeApply

Fields

runMaybeApply :: Either (f a) a

Instances

Functor f => Functor (MaybeApply f)

FunctorApply f => Applicative (MaybeApply f)

Comonad f => Comonad (MaybeApply f)

FunctorApply f => FunctorApply (MaybeApply f)

ComonadApply w => ComonadApply (MaybeApply w)