Search results

sequence :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)

sequence1 :: forall t b f. Traversable1 t => Apply f => t (f b) -> f (t b)

sequence1Default :: forall t a m. Traversable1 t => Apply m => t (m a) -> m (t a)

A default implementation of sequence1 using traverse1.

sequenceDefault :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)

A default implementation of sequence using traverse.

distribute :: forall f a g. Distributive f => Functor g => g (f a) -> f (g a)

distributeDefault :: forall a f g. Distributive f => Functor g => g (f a) -> f (g a)

A default implementation of distribute, based on collect.

parSequence :: forall a t m f. Parallel f m => Applicative f => Traversable t => t (m a) -> m (t a)

sequence :: forall m p q a. Dissect p q => MonadRec m => p (m a) -> m (p a)

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

sequence :: forall c b a. HasApply b => HasMap b => HasTraverse a => HasPure b => a (b c) -> b (a c)

Sequences actions and collects the results.

sequence [Just 1, Just 2] -- Just [1, 2]

oneOf :: forall f g a. Foldable f => Plus g => f (g a) -> g a

Combines a collection of elements using the Alt operation.

oneOf :: forall m f a. MonadGen m => Foldable1 f => f (m a) -> m a

Creates a generator that outputs a value chosen from a selection of existing generators with uniform probability.

parOneOf :: forall a t m f. Parallel f m => Alternative f => Foldable t => Functor t => t (m a) -> m a

Race a collection in parallel.

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

wrapFree :: forall f m a. MonadFree f m => f (m a) -> m a

choice :: forall a g f. Foldable f => Alt g => Plus g => f (g a) -> g a

oneOf :: forall a m f. Foldable f => Alternative m => f (m a) -> m a

restoreM :: forall base m stM a. MonadBaseControl base m stM => base (stM a) -> m a

join :: forall a m. Bind m => m (m a) -> m a

Collapse two applications of a monadic type constructor into one.

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

Duplicate a comonadic context.

duplicate is dual to Control.Bind.join.

keepLatest :: forall event a. IsEvent event => event (event a) -> event a

keepLatest :: forall event a. IsEvent event => event (event a) -> event a

join :: forall v m c. HasBind c m => HasIdentity c => ObjectOf c (m v) => m (m v) -> m v

flatten :: forall b a. HasChain a => a (a b) -> a b

Removes a level of nesting from a container.

flatten [[1, 2], [3, 4]] -- [1, 2, 3, 4]

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

warbler :: forall m a. Bind m => m (m a) -> m a

W combinator - warbler - omega

MM

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

λ f x . f x x

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.

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)

integrateM :: forall a stM m base. Applicative base => MonadBaseControl base m stM => m (stM a) -> m a

Pack a state belonging to m back into it, instead of throwing it away

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

Run the given action inside the base monad b.

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

elements :: forall m f a. MonadGen m => Foldable1 f => f a -> m a

Creates a generator that outputs a value chosen from a selection with uniform probability.

inj :: forall f g a. Inject f g => f a -> g a

join :: forall f m a. MonadFork f m => f a -> m a

liftBase :: forall b m a. MonadBase b m => b a -> m a

length :: forall sproxy proxy a b. Length a b => sproxy a -> proxy b

parseInt :: forall sproxy proxy sym a. ParseInt sym a => sproxy sym -> proxy a

parse Int a Value-Level

parseInt (Proxy  :: _ "-1337") ~> N1337
parseInt (SProxy :: _ "-1337") ~> N1337
    -- N1137 would be type alias for Neg (Succ^1337 Z)

parseNat :: forall sproxy proxy sym a. ParseNat sym a => sproxy sym -> proxy a

value-level parse of number

parseNat (Proxy  "10") ~> D10
parseNat (SProxy "10") ~> D10

length :: forall xs r lproxy iproxy. Length xs r => lproxy xs -> iproxy r

forever :: forall m a b. MonadRec m => m a -> m b

forever runs an action indefinitely, using the MonadRec instance to ensure constant stack usage.

For example:

main = forever $ trace "Hello, World!"

proof :: forall a b p. TypeEquals a b => p a -> p b

coerce :: forall f a b. Contravariant f => Functor f => f a -> f b

uninterruptible :: forall e f m a. MonadBracket e f m => m a -> m a

cleared :: forall f a b. Filterable f => f a -> f b

Filter out all values.

folded :: forall event a. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

folded :: forall a event. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

sort :: forall f a. Functor f => Foldable f => Unfoldable f => Ord a => f a -> f a

Sort any structure (which has Foldable, Unfoldable, and Functor instances) by converting to an OrdSeq and back again. I am fairly sure this is usually O(n*log(n)), although of course this depends on the Unfoldable and Foldable instances.

init :: forall xs ys lproxy. Init xs ys => lproxy xs -> lproxy ys

restoreAfter :: forall m a. MonadCanvasAction m => m a -> m a

Runs save, then the provided action, then restore

drain :: forall a s n n1. ToString n1 s => IsSymbol s => Analytic (a n) => Analytic (a n1) => Add n1 1 n => a n -> a n1

Decrement the dimension of a point/vector by removing its last coordinate.