Search results

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

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

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

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

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

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

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

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.

sampleOnRight_ :: forall event a b. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

sampleOn_ :: forall b a event. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

applyFirst :: forall v1 v0 f c. HasApply c f => HasConst c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v0) => f v0 -> f v1 -> f v0

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

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

Get a value which depends on the environment.

mulNat :: forall proxy a b c. ProductNat a b c => proxy a -> proxy b -> proxy c

plus :: forall proxy a b c. SumInt a b c => proxy a -> proxy b -> proxy c

plusNat :: forall proxy a b c. SumNat a b c => proxy a -> proxy b -> proxy c

powNat :: forall proxy a b c. ExponentiationNat a b c => proxy a -> proxy b -> proxy c

> powNat d2 d3
8 -- : NProxy D8

a raised to the power of b a^b = c

prod :: forall proxy a b c. ProductInt a b c => proxy a -> proxy b -> proxy c

concat :: forall xs ys zs lproxy. Concat xs ys zs => lproxy xs -> lproxy ys -> lproxy zs

drop :: forall n xs ys lproxy iproxy. Drop n xs ys => iproxy n -> lproxy xs -> lproxy ys

take :: forall n xs ys lproxy iproxy. Take n xs ys => iproxy n -> lproxy xs -> lproxy ys

zip :: forall x y z lproxy. Zip x y z => lproxy x -> lproxy y -> lproxy z

map :: forall f xs ys fproxy kproxy lproxy. Map f xs ys => fproxy f -> kproxy xs -> lproxy ys

getOrAlt :: forall v s r' r l h g f. Alternative h => Cons s v r' r => RowToList r l => RGetOrAlt f g s l r => g s -> f r -> h v

alt :: forall f a. Alt f => f a -> f a -> f a

choose :: forall m a. MonadGen m => m a -> m a -> m a

Creates a generator that outputs a value chosen from one of two existing existing generators with even probability.

max1 :: forall f a. Ord1 f => f a -> f a -> f a

min1 :: forall f a. Ord1 f => f a -> f a -> f a

onIntegrityError :: forall m a. MonadError PGError m => m a -> m a -> m a

alt :: forall f a. Alternative f => f a -> f a -> f a

dappend :: forall cnt a. Diff cnt => cnt a -> cnt a -> cnt a

interleave :: forall m a. MonadLogic m => m a -> m a -> m a

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 Trivial) or types with truncating Unfoldable1 instances (like Maybe).

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

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

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.

sampleOnLeft_ :: forall event a b. IsEvent event => event a -> event b -> event b

applySecond :: forall v1 v0 f c. HasApply c f => HasConst c => HasIdentity c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v1) => ObjectOf c (c v0 (c v1 v1)) => ObjectOf c (c (c v1 v1) (c v0 (c v1 v1))) => f v0 -> f v1 -> f v1

fromFoldableL :: forall a c f. Foldable f => Consable c => c a -> f a -> c a

Conversion from Foldable to Consable using foldl.

fromFoldableL [] [1,2,3,4]  == [4,3,2,1]
fromFoldableL [0] [1,2,3,4] == [4,3,2,1,0]

fromFoldableR :: forall a c f. Foldable f => Consable c => c a -> f a -> c a

Conversion from Foldable to Consable using foldr.

fromFoldableR [] [1,2,3,4]  == [1,2,3,4]
fromFoldableR [5] [1,2,3,4] == [1,2,3,4,5]

voidRight :: forall f a b. Functor f => a -> f b -> f a

Ignore the return value of a computation, using the specified return value instead.

functorDecorate :: forall b a f. Functor f => Decorate a b => a -> f b -> f a

seek :: forall s a w. ComonadStore s w => s -> w a -> w a

Reposition the focus at the specified position.

filled :: forall m a style. MonadCanvasAction m => CanvasStyle style => style -> m a -> m a

Run a MonadCanvasAction with the given fillStyle, resetting it to the previous value after

putCtx :: forall a html ctx. Ctx ctx html => ctx -> html a -> html a

stroked :: forall m a style. MonadCanvasAction m => CanvasStyle style => style -> m a -> m a

Run a MonadCanvasAction with the given strokeStyle, resetting it to the previous value after

tellAccum :: forall acc html a. TellAccum acc html => acc -> html a -> html a

scalarMul :: forall f k. VectorField f k => k -> f k -> f k

• ∀v in V: one * v == v
• ∀a b in K, v in V: a * (b .* v) = (a * b) .* v
• ∀a b in K, v in V:
  • a .* (u + v) = a .* u + a .* v
  • (a + b) .* v = a .* v + b .* v

cons :: forall t a. Consable t => a -> t a -> t a

cons :: forall f a. Container f => a -> f a -> f a

insert :: forall f a. Container f => Ord a => a -> f a -> f a

option :: forall a m. Alternative m => a -> m a -> m a

replaceInArray :: forall a f. HasUuid a => Functor f => a -> f a -> f a

apply :: forall a b. (a -> b) -> a -> b

Applies a function to an argument. This is primarily used as the operator ($) which allows parentheses to be omitted in some cases, or as a natural way to apply a chain of composed functions to a value.

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

Given a constructor for a Newtype, this returns the appropriate unwrap function.

memoize :: forall a b. Tabulate a => (a -> b) -> a -> b

Memoize a function of one argument

flipScalarMul :: forall k f. VectorField f k => f k -> k -> f k

get :: forall v s r' r l g f. Cons s v r' r => RGet f g s l r => RowToList r l => g s -> f r -> v

match :: forall v r1 r0 l1 l0 g f. RMatch f g v l0 r0 l1 r1 => RowToList r0 l0 => RowToList r1 l1 => f r0 -> g r1 -> v

memoize :: forall b a. Tabulate a => (a -> b) -> a -> b

Memoize a function of one argument

over :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses Function s t a b => (a -> b) -> s -> t

applicator :: forall b a. (a -> b) -> a -> b

A combinator - applicator

Λ a b . (a → b) → a → b

λ f x . f x

foldMap :: forall a b s. Convert s (Statements a) => Monoid b => (a -> b) -> s -> b

idstar :: forall b a. (a -> b) -> a -> b

I* combinator - id bird once removed

S(SK)

Λ a b . (a → b) → a → b

λ f x . f x

local :: forall a b r. (a -> b) -> (Ask b => r) -> (Ask a => r)

Run a function over an implicit parameter

Note: Be careful while using this to map over the value without updating the type.

-- evaluates to `1`, not `2`
provide 1 (local ((*) 2) (ask @Int))

mapUndefined :: forall b a. (a -> b) -> a -> b

memoize :: forall a b. (a -> b) -> a -> b

Memoize the function f. If the argument of f differs from the previous call, then f is recomputed.

moldMap :: forall t e m. Moldable t e => Monoid m => (e -> m) -> t -> m

moldMapDefaultL :: forall m e t. Moldable t e => Monoid m => (e -> m) -> t -> m

moldMapDefaultR :: forall m e t. Moldable t e => Monoid m => (e -> m) -> t -> m

A default implementation of moldMap based on moldr

nmap :: forall fa fb a b. NestedFunctor fa fb a b => (a -> b) -> fa -> fb

snoc :: forall f a. Container f => f a -> a -> f a

voidLeft :: forall f a b. Functor f => f a -> b -> f b

A version of voidRight with its arguments flipped.

rsingleton :: forall f g s v r. RSingleton f g s => Cons s v () r => Lacks s () => g s -> v -> f r

singleton :: forall v s r g f. Cons s v () r => Lacks s () => RSingleton f g s => g s -> v -> f r

functorDecorateFlipped :: forall b a f. Functor f => Decorate b a => f a -> b -> f b

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

transAnaT :: forall t f. Recursive t f => Corecursive t f => (t -> t) -> t -> t

transCataT :: forall t f. Recursive t f => Corecursive t f => (t -> t) -> t -> t

everywhere :: forall a. Data a => (forall b. Data b => b -> b) -> a -> a

Apply a transformation everywhere, bottom-up

everywhere' :: forall a. Data a => (forall b. Data b => b -> b) -> a -> a

Apply a transformation everywhere, top-down

gmapT :: forall a. Data a => (forall b. Data b => b -> b) -> a -> a

A generic transformation that maps over the immediate subterms

mkT :: forall a b. Typeable a => Typeable b => (b -> b) -> a -> a

askRunInBase :: forall b m a. MonadUnlift b m => m (m a -> b a)

A monomorphic version of askUnlift which can be more convenient when you only want to use the resulting runner function once with a concrete type.

If you run into type issues using this, try using askUnlit instead.

askRunBase :: forall a stM m base. MonadBaseUnlift base m stM => Applicative base => m (m a -> base a)

duplicate :: forall a w. Extend w => w a -> w (w a)

Duplicate a comonadic context.

duplicate is dual to Control.Bind.join.

intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m

Fold a data structure, accumulating values in some Monoid, combining adjacent elements using the specified separator.

For example:

> intercalate ", " ["Lorem", "ipsum", "dolor"]
= "Lorem, ipsum, dolor"

> intercalate "*" ["a", "b", "c"]
= "a*b*c"

> intercalate [1] [[2, 3], [4, 5], [6, 7]]
= [2, 3, 1, 4, 5, 1, 6, 7]

intercalate :: forall f m. Foldable1 f => Semigroup m => m -> f m -> m

Fold a data structure using a Semigroup instance, combining adjacent elements using the specified separator.

surround :: forall f m. Foldable f => Semigroup m => m -> f m -> m

fold but with each element surrounded by some fixed value.

For example:

> surround "*" []
= "*"

> surround "*" ["1"]
= "*1*"

> surround "*" ["1", "2"]
= "*1*2*"

> surround "*" ["1", "2", "3"]
= "*1*2*3*"

unfoldable :: forall m f a. MonadRec m => MonadGen m => Unfoldable f => m a -> m (f a)

Creates a generator that produces unfoldable structures based on an existing generator for the elements.

The size of the unfoldable will be determined by the current size state for the generator. To generate an unfoldable structure of a particular size, use the resize function from the MonadGen class first.

enumFromTo :: forall a u. Enum a => Unfoldable1 u => a -> a -> u a

Returns a contiguous sequence of elements from the first value to the second value (inclusive).

enumFromTo 0 3 = [0, 1, 2, 3]
enumFromTo 'c' 'a' = ['c', 'b', 'a']

The example shows Array return values, but the result can be any type with an Unfoldable1 instance.

asks :: forall r m a. MonadAsk r m => (r -> a) -> m a

Projects a value from the global context in a MonadAsk.

gets :: forall s m a. MonadState s m => (s -> a) -> m a

Get a value which depends on the current state.

peek :: forall s w a. ComonadStore s w => s -> w a -> a

track :: forall t w a. ComonadTraced t w => t -> w a -> a

unwrapCofree :: forall f w a. ComonadCofree f w => w a -> f (w a)

fork :: forall f m a. MonadFork f m => m a -> m (f a)

suspend :: forall f m a. MonadFork f m => m a -> m (f a)

buildLeaf :: forall e f p v. ElementBuilder e f p v => e -> f p -> v

toBase :: forall b m a. MonadUnlift b m => m a -> m (b a)

Run the given action inside the base monad b.

consMax :: forall a f. Foldable f => Ord a => a -> f a -> a

consMin :: forall a f. Foldable f => Ord a => a -> f a -> a

foldEnum :: forall a b. BoundedEnum a => Semigroup b => (a -> b) -> b

Map each element of a BoundedEnum into a semigroup, and combine the results through refold1.

invokeAction :: forall m res args ctrl act. RemoteAction act ctrl args res => MonadReader Visualforce m => MonadAff m => MonadError RemoteActionError m => IsSymbol ctrl => Encode args => Decode res => act -> args -> m res

Function that invoke the action defined by referring to contraints which holds details about the correct controller to invoke. Example:

data PCMRequests = ..

data CreatePCMRequests = CreatePCMRequests

instance remoteActionCreatePCMs :: RemoteAction CreatePCMRequests "PCMMassController.createRecords" PCMRequests Unit

createPCMRequest :: Visualforce -> PCMRequests -> Aff (Either RemoteActionError Unit)
createPCMRequest vf rec =  runReaderT (runExceptT $ invokeAction CreatePCMRequests rec) vf

split :: forall f a. Applicative f => f a -> f (f a)

tabulate :: forall f a b. Representable f a => (a -> b) -> f b

fix :: forall l. Lazy l => (l -> l) -> l

fix defines a value as the fixed point of a function.

The Lazy instance allows us to generate the result lazily.

modify :: forall s m. MonadState s m => (s -> s) -> m s

Modify the state by applying a function to the current state. The returned value is the new state value.

fix :: forall a. (a -> a) -> a

Fixed point Y combinator

Λ a . (a → a) → a

λ f . (λ x. f (x x)) (λ x . f (x x))

fix :: forall a. (a -> a) -> a

convertOption :: forall field from to sproxy. ConvertOption field from to => sproxy field -> from -> to

index :: forall f a b. Representable f a => f b -> (a -> b)

lift :: forall a g f. Applicative f => Applicative g => a -> f (g a)

add :: forall a. Semiring a => a -> a -> a

append :: forall a. Semigroup a => a -> a -> a

conj :: forall a. HeytingAlgebra a => a -> a -> a

const :: forall a b. a -> b -> a

Returns its first argument and ignores its second.

const 1 "hello" = 1

It can also be thought of as creating a function that ignores its argument:

const 1 = \_ -> 1

disj :: forall a. HeytingAlgebra a => a -> a -> a

div :: forall a. EuclideanRing a => a -> a -> a

gcd :: forall a. Eq a => EuclideanRing a => a -> a -> a

The greatest common divisor of two values.

genericAdd :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the add member from the Semiring type class.

genericAdd' :: forall a. GenericSemiring a => a -> a -> a

genericAppend :: forall a rep. Generic a rep => GenericSemigroup rep => a -> a -> a

A Generic implementation of the append member from the Semigroup type class.

genericAppend' :: forall a. GenericSemigroup a => a -> a -> a

genericConj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the conj member from the HeytingAlgebra type class.

genericConj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericDisj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the disj member from the HeytingAlgebra type class.

genericDisj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericImplies :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the implies member from the HeytingAlgebra type class.

genericImplies' :: forall a. GenericHeytingAlgebra a => a -> a -> a