Search results

sequence :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)
P purescript-foldable-traversable M Data.Traversable
sequence1 :: forall t b f. Traversable1 t => Apply f => t (f b) -> f (t b)
P purescript-foldable-traversable M Data.Semigroup.Traversable
sequence1Default :: forall t a m. Traversable1 t => Apply m => t (m a) -> m (t a)

A default implementation of sequence1 using traverse1.

P purescript-foldable-traversable M Data.Semigroup.Traversable
sequenceDefault :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)

A default implementation of sequence using traverse.

P purescript-foldable-traversable M Data.Traversable
distribute :: forall f a g. Distributive f => Functor g => g (f a) -> f (g a)
P purescript-distributive M Data.Distributive
distributeDefault :: forall a f g. Distributive f => Functor g => g (f a) -> f (g a)

A default implementation of distribute, based on collect.

P purescript-distributive M Data.Distributive
parSequence :: forall a t m f. Parallel f m => Traversable t => t (m a) -> m (t a)
P purescript-parallel M Control.Parallel
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]
P purescript-neon M Neon.Helper
oneOf :: forall f g a. Foldable f => Plus g => f (g a) -> g a

Combines a collection of elements using the Alt operation.

P purescript-foldable-traversable M Data.Foldable
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.

P purescript-gen M Control.Monad.Gen
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.

P purescript-parallel M Control.Parallel
unwrapCofree :: forall f w a. ComonadCofree f w => w a -> f (w a)
P purescript-free M Control.Comonad.Cofree.Class
wrapFree :: forall f m a. MonadFree f m => f (m a) -> m a
P purescript-free M Control.Monad.Free.Class
choice :: forall a g f. Foldable f => Alt g => Plus g => f (g a) -> g a
P purescript-simple-parser M Text.Parsing.Simple
oneOf :: forall a m f. Foldable f => Alternative m => f (m a) -> m a
P purescript-parsers M Text.Parsing.Combinators
restoreM :: forall base m stM a. MonadBaseControl base m stM => base (stM a) -> m a
P purescript-monad-control M Control.Monad.Trans.Control
join :: forall a m. Bind m => m (m a) -> m a

Collapse two applications of a monadic type constructor into one.

P purescript-prelude M Control.Bind
duplicate :: forall a w. Extend w => w a -> w (w a)

Duplicate a comonadic context.

duplicate is dual to Control.Bind.join.

P purescript-control M Control.Extend
keepLatest :: forall event a. IsEvent event => event (event a) -> event a
P purescript-event M FRP.Event.Class
join :: forall v m c. HasBind c m => HasIdentity c => ObjectOf c (m v) => m (m v) -> m v
P purescript-subcategory M Control.Subcategory.Functor.HasBind
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]
P purescript-neon M Neon.Helper
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

P purescript-birds M Aviary.Birds
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.

P purescript-gen M Control.Monad.Gen
fork :: forall f m a. MonadFork f m => m a -> m (f a)
P purescript-fork M Control.Monad.Fork.Class
suspend :: forall f m a. MonadFork f m => m a -> m (f a)
P purescript-fork M Control.Monad.Fork.Class
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

P purescript-monad-control M Control.Monad.Trans.Control
lift :: forall a g f. Applicative f => Applicative g => a -> f (g a)
P purescript-simple-parser M Text.Parsing.Util
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.

P purescript-gen M Control.Monad.Gen
inj :: forall f g a. Inject f g => f a -> g a
P purescript-functors M Data.Functor.Coproduct.Inject
join :: forall f m a. MonadFork f m => f a -> m a
P purescript-fork M Control.Monad.Fork.Class
liftBase :: forall b m a. MonadBase b m => b a -> m a
P purescript-monad-control M Control.Monad.Base
length :: forall sproxy proxy a b. Length a b => sproxy a -> proxy b
P purescript-typelevel-peano M Type.Data.Peano.Nat.Parse
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)
P purescript-typelevel-peano M Type.Data.Peano.Int.Parse
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
P purescript-typelevel-peano M Type.Data.Peano.Nat.Parse
length :: forall r xs lproxy iproxy. Length xs r => lproxy xs -> iproxy r
P purescript-typelevel-lists M Type.Data.List
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!"
P purescript-tailrec M Control.Monad.Rec.Class
coerce :: forall f a b. Contravariant f => Functor f => f a -> f b
P purescript-contravariant M Data.Functor.Contravariant
uninterruptible :: forall e f m a. MonadBracket e f m => m a -> m a
P purescript-fork M Control.Monad.Fork.Class
cleared :: forall f a b. Filterable f => f a -> f b

Filter out all values.

P purescript-filterable M Data.Filterable
folded :: forall a event. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

P purescript-event M FRP.Event.Class
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.

P purescript-sequences M Data.Sequence.Ordered
restoreAfter :: forall m a. MonadCanvasAction m => m a -> m a

Runs save, then the provided action, then restore

P purescript-canvas-action M Graphics.CanvasAction
forever :: forall b a m. Monad m => m a -> m b
P purescript-game M Game.Util
init :: forall xs ys lproxy. Init xs ys => lproxy xs -> lproxy ys
P purescript-typelevel-lists M Type.Data.List
lookAhead :: forall m a. LookAheadParsing m => m a -> m a
P purescript-parsers M Text.Parsing.Classes
once :: forall a m. MonadLogic m => m a -> m a
P purescript-logic M Control.Monad.Logic.Class
try :: forall m a. Parsing m => m a -> m a
P purescript-parsers M Text.Parsing.Classes
pure :: forall f a. Applicative f => a -> f a
P purescript-prelude M Control.Applicative
extract :: forall w a. Comonad w => w a -> a
P purescript-control M Control.Comonad
and :: forall a f. Foldable f => HeytingAlgebra a => f a -> a

The conjunction of all the values in a data structure. When specialized to Boolean, this function will test whether all of the values in a data structure are true.

P purescript-foldable-traversable M Data.Foldable