Search results

fmapL :: forall r e' e. (e -> e') -> Either e r -> Either e' r

Map a function over the Left value of an Either

mapLeft :: forall l r l2. (l -> l2) -> Either l r -> Either l2 r

lmap :: forall f a b c. Bifunctor f => (a -> b) -> f a c -> f b c

Map a function over the first type argument of a Bifunctor.

lcmap :: forall a b c p. Profunctor p => (a -> b) -> p b c -> p a c

Map a function over the (contravariant) first type argument only.

dlmap :: forall p c b a. Profunctor p => (a -> b) -> p b c -> p a c

throwLeftAs :: forall err m left right. MonadThrow err m => (left -> err) -> Either left right -> m right

Turns a Left a into an exception which reduces nesting

wrapIso :: forall p t a. Profunctor p => Newtype t a => (a -> t) -> p a a -> p t t

wrapIso :: forall v1 v0 p. HasDimap Function p => Newtype v0 v1 => ObjectOf Function v1 => ObjectOf Function v0 => (v0 -> v1) -> p v0 v0 -> p v1 v1

rmap :: forall f a b c. Bifunctor f => (b -> c) -> f a b -> f a c

Map a function over the second type arguments of a Bifunctor.

rmap :: forall a b c p. Profunctor p => (b -> c) -> p a b -> p a c

Map a function over the (covariant) second type argument only.

drmap :: forall p c b a. Profunctor p => (b -> c) -> p a b -> p a c

censor :: forall w m a. MonadWriter w m => (w -> w) -> m a -> m a

Modify the final accumulator value by applying a function.

local :: forall e w a. ComonadEnv e w => (e -> e) -> w a -> w a

local :: forall r m a. MonadReader r m => (r -> r) -> m a -> m a

seeks :: forall s a w. ComonadStore s w => (s -> s) -> w a -> w a

Reposition the focus at the specified position, which depends on the current position.

censorAccum :: forall acc html a. Accum acc html => (acc -> acc) -> html a -> html a

setCtx :: forall ctx html a. Ctx ctx html => (ctx -> ctx) -> html a -> html a

mapErr :: forall e m a. MonadError e m => (e -> e) -> m a -> m a

defaultFilter :: forall a h f. BooleanEq h => Applicative f => Foldable f => Monoid (f a) => (a -> h) -> f a -> f a

filter :: forall f h a. Filterable f => BooleanEq h => (a -> h) -> f a -> f a

liftA1 :: forall f a b. Applicative f => (a -> b) -> f a -> f b

liftA1 provides a default implementation of (<$>) for any Applicative functor, without using (<$>) as provided by the Functor-Applicative superclass relationship.

liftA1 can therefore be used to write Functor instances as follows:

instance functorF :: Functor F where
  map = liftA1

liftM1 :: forall m a b. Monad m => (a -> b) -> m a -> m b

liftM1 provides a default implementation of (<$>) for any Monad, without using (<$>) as provided by the Functor-Monad superclass relationship.

liftM1 can therefore be used to write Functor instances as follows:

instance functorF :: Functor F where
  map = liftM1

map :: forall f a b. Functor f => (a -> b) -> f a -> f b

mapDefault :: forall i f a b. FunctorWithIndex i f => (a -> b) -> f a -> f b

A default implementation of Functor's map in terms of mapWithIndex

cmap :: forall f a b. Contravariant f => (b -> a) -> f a -> f b

squigglyMap :: forall f a b. Functor f => (a -> b) -> f a -> f b

map :: forall p q a b. Dissect p q => (a -> b) -> p a -> p b

A tail-recursive map operation, implemented in terms of Dissect.

map :: forall a c b. HasMap a => (b -> c) -> a b -> a c

map :: forall f a b. Functor f => (a -> b) -> f a -> f b

peeks :: forall s a w. ComonadStore s w => (s -> s) -> w a -> a

Extract a value from a position which depends on the current position.

mapFlipped :: forall v1 v0 f c. HasMap c f => ObjectOf c v0 => ObjectOf c v1 => f v0 -> c v0 v1 -> f v1

asks :: forall e1 e2 w a. ComonadAsk e1 w => (e1 -> e2) -> w a -> e2

Get a value which depends on the environment.

amodify :: forall m r s. MonadEffect m => Refer s r => (s -> s) -> r -> m s

iterate :: forall a u. Unfoldable1 u => (a -> a) -> a -> u a

Create an infinite Unfoldable1 by repeated application of a function to a seed value. Analogous to iterateN, but with no iteration limit.

This should only be used to produce either lazy types (like lazy Lists) or types with truncating Unfoldable1 instances (like Maybe).

all :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b

all f is the same as and <<< map f; map a function over the structure, and then get the conjunction of the results.

any :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b

any f is the same as or <<< map f; map a function over the structure, and then get the disjunction of the results.

foldMap :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m

foldMap1 :: forall t a m. Foldable1 t => Semigroup m => (a -> m) -> t a -> m

foldMap1DefaultL :: forall t m a. Foldable1 t => Functor t => Semigroup m => (a -> m) -> t a -> m

A default implementation of foldMap1 using foldl1.

Note: when defining a Foldable1 instance, this function is unsafe to use in combination with foldl1Default.

foldMap1DefaultR :: forall t m a. Foldable1 t => Functor t => Semigroup m => (a -> m) -> t a -> m

A default implementation of foldMap1 using foldr1.

Note: when defining a Foldable1 instance, this function is unsafe to use in combination with foldr1Default.

foldMapDefault :: forall i f a m. FoldableWithIndex i f => Monoid m => (a -> m) -> f a -> m

A default implementation of foldMap using foldMapWithIndex

foldMapDefaultL :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m

A default implementation of foldMap using foldl.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldlDefault.

foldMapDefaultR :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m

A default implementation of foldMap using foldr.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldrDefault.

tracks :: forall w a t. ComonadTraced t w => (a -> t) -> w a -> a

Extracts a value at a relative position which depends on the current value.

areads :: forall m r s a. MonadEffect m => Refer s r => (s -> a) -> r -> m a

liftF :: forall b a f. Applicative f => (a -> b) -> a -> f b

applySecond :: forall a b f. Apply f => f a -> f b -> f b

Combine two effectful actions, keeping only the result of the second.

modify :: forall t a. Newtype t a => (a -> a) -> t -> t

This combinator unwraps the newtype, applies a monomorphic function to the contained value and wraps the result back in the newtype

fromLeft :: forall a b. a -> Either a b -> a

A function that extracts the value from the Left data constructor. The first argument is a default value, which will be returned in the case where a Right is passed to fromLeft.

fromRight :: forall a b. b -> Either a b -> b

A function that extracts the value from the Right data constructor. The first argument is a default value, which will be returned in the case where a Left is passed to fromRight.