Safe Haskell	Safe

Eta.Classes.Functor

Contents

Map forward
Map backwards
Discard

Description

The Functor type class defines that a type can have a map operation which can be used to map a function over the elements of it.

The list and the Maybe types are examples of instances of Functor.

Mnemonic: Mappable

Synopsis

Documentation

>>> import Prelude ((+))

map :: Functor f => (a -> b) -> f a -> f b #

Maps a function over a value

>>> map (+1) [1,2,3]
[2,3,4]

Map forward

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

Maps the function of the right to the Functor of the left:

>>> [1,2,3] |$> (+ 1)
[2,3,4]

Map backwards

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

Maps the function of the left to the Functor of the right:

>>> (+1) <$| [1,2,3]
[2,3,4]

Discard

discard :: Functor f => f a -> f () #

Discards the value inside of the functor.

>>> discard [1,2,3]
[(),(),()]

class Functor f where #

Minimal complete definition

fmap

Methods

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

Instances

Functor []
Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a]
Functor Maybe
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a
Functor IO
Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a
Functor V1
Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a
Functor U1
Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a
Functor Par1
Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a
Functor Handler
Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a
Functor Sum
Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a
Functor Product
Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a
Functor Last
Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a
Functor First
Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a
Functor Dual
Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a
Functor ZipList
Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a
Functor Id
Methods fmap :: (a -> b) -> Id a -> Id b # (<$) :: a -> Id b -> Id a
Functor ((->) r)
Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a
Functor (Either a)
Methods fmap :: (a -> b) -> Either a a -> Either a b # (<$) :: a -> Either a b -> Either a a
Functor f => Functor (Rec1 f)
Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a
Functor (URec Char)
Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a
Functor (URec Double)
Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a
Functor (URec Float)
Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a
Functor (URec Int)
Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a
Functor (URec Word)
Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a
Functor (URec (Ptr ()))
Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a
Functor ((,) a)
Methods fmap :: (a -> b) -> (a, a) -> (a, b) # (<$) :: a -> (a, b) -> (a, a)
Monad m => Functor (WrappedMonad m)
Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a
Functor (Proxy *)
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b # (<$) :: a -> Proxy * b -> Proxy * a
Functor (StateR s)
Methods fmap :: (a -> b) -> StateR s a -> StateR s b # (<$) :: a -> StateR s b -> StateR s a
Functor (StateL s)
Methods fmap :: (a -> b) -> StateL s a -> StateL s b # (<$) :: a -> StateL s b -> StateL s a
Functor (K1 i c)
Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a
(Functor g, Functor f) => Functor ((:+:) f g)
Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a
(Functor g, Functor f) => Functor ((:*:) f g)
Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a
(Functor g, Functor f) => Functor ((:.:) f g)
Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a
Functor f => Functor (Alt * f)
Methods fmap :: (a -> b) -> Alt * f a -> Alt * f b # (<$) :: a -> Alt * f b -> Alt * f a
Arrow a => Functor (WrappedArrow a b)
Methods fmap :: (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b # (<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a
Functor f => Functor (M1 i c f)
Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a