Stuff

log :: String -> IOSync Unit

logError :: String -> IOSync Unit

logInfo :: String -> IOSync Unit

logWarning :: String -> IOSync Unit

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

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

Operator alias for Control.Semigroupoid.compose (right-associative / precedence 9)

Operator alias for Data.Either.Either (right-associative / precedence 6)

class (Functor f) <= Alt f 

The Alt type class identifies an associative operation on a type constructor. It is similar to Semigroup, except that it applies to types of kind * -> *, like Array or List, rather than concrete types String or Number.

Alt instances are required to satisfy the following laws:

• Associativity: (x <|> y) <|> z == x <|> (y <|> z)
• Distributivity: f <$> (x <|> y) == (f <$> x) <|> (f <$> y)

For example, the Array ([]) type is an instance of Alt, where (<|>) is defined to be concatenation.

Instances

• Alt Array

Operator alias for Control.Alt.alt (left-associative / precedence 3)

class (Applicative f, Plus f) <= Alternative f 

The Alternative type class has no members of its own; it just specifies that the type constructor has both Applicative and Plus instances.

Types which have Alternative instances should also satisfy the following laws:

• Distributivity: (f <|> g) <*> x == (f <*> x) <|> (g <*> x)
• Annihilation: empty <*> f = empty

Instances

• Alternative Array

lift5 :: forall g f e d c b a. Apply f => (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g

Lift a function of five arguments to a function which accepts and returns values wrapped with the type constructor f.

lift4 :: forall f e d c b a. Apply f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e

Lift a function of four arguments to a function which accepts and returns values wrapped with the type constructor f.

lift3 :: forall f d c b a. Apply f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

Lift a function of three arguments to a function which accepts and returns values wrapped with the type constructor f.

lift2 :: forall f c b a. Apply f => (a -> b -> c) -> f a -> f b -> f c

Lift a function of two arguments to a function which accepts and returns values wrapped with the type constructor f.

class (Biapply w) <= Biapplicative w  where

Biapplicative captures type constructors of two arguments which support lifting of functions of zero or more arguments, in the sense of Applicative.

Members

• bipure :: forall b a. a -> b -> w a b

class (Bifunctor w) <= Biapply w 

Biapply captures type constructors of two arguments which support lifting of functions of one or more arguments, in the sense of Apply.

bilift3 :: forall h g f e d c b a w. Biapply w => (a -> b -> c -> d) -> (e -> f -> g -> h) -> w a e -> w b f -> w c g -> w d h

Lift a function of three arguments.

bilift2 :: forall f e d c b a w. Biapply w => (a -> b -> c) -> (d -> e -> f) -> w a d -> w b e -> w c f

Lift a function of two arguments.

Operator alias for Control.Biapply.biapply (left-associative / precedence 4)

Operator alias for Control.Biapply.biapplySecond (left-associative / precedence 4)

Operator alias for Control.Category.id (left-associative / precedence 4)

A convenience operator which can be used to apply the result of bipure in the style of Applicative:

bipure f g <<$>> x <<*>> y

Operator alias for Control.Biapply.biapplyFirst (left-associative / precedence 4)

class (Extend w) <= Comonad w  where

Comonad extends the Extend class with the extract function which extracts a value, discarding the comonadic context.

Comonad is the dual of Monad, and extract is the dual of pure.

Laws:

• Left Identity: extract <<= xs = xs
• Right Identity: extract (f <<= xs) = f xs

Members

• extract :: forall a. w a -> a

class (Functor w) <= Extend w  where

The Extend class defines the extension operator (<<=) which extends a local context-dependent computation to a global computation.

Extend is the dual of Bind, and (<<=) is the dual of (>>=).

Laws:

• Associativity: extend f <<< extend g = extend (f <<< extend g)

Members

• extend :: forall a b. (w a -> b) -> w a -> w b

Instances

• (Semigroup w) => Extend (Function w)

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

Duplicate a comonadic context.

duplicate is dual to Control.Bind.join.

Operator alias for Control.Extend.extendFlipped (left-associative / precedence 1)

Operator alias for Control.Extend.composeCoKleisli (right-associative / precedence 1)

Operator alias for Control.Extend.composeCoKleisliFlipped (right-associative / precedence 1)

Operator alias for Control.Extend.extend (right-associative / precedence 1)

liftAff :: forall eff m a. MonadAff eff m => Aff eff a -> m a

liftEff :: forall eff m a. MonadEff eff m => Eff eff a -> m a

data Error :: Type

The type of JavaScript errors

Instances

• Show Error

newtype IO a

Instances

• Newtype (IO a) _
• Functor IO
• Apply IO
• Applicative IO
• Bind IO
• Monad IO
• MonadRec IO
• (Semigroup a) => Semigroup (IO a)
• (Monoid a) => Monoid (IO a)
• MonadAff eff IO
• MonadEff eff IO
• MonadThrow Error IO
• MonadError Error IO
• Alt IO
• Plus IO
• Alternative IO
• MonadZero IO

runIO' :: forall eff. IO ~> (Aff (infinity :: INFINITY | eff))

runIO :: IO ~> (Aff (infinity :: INFINITY))

launchIO :: forall a. IO a -> IOSync Unit

class (Monad m) <= MonadIO m  where

Members

• liftIO :: IO ~> m

Instances

• MonadIO IO

newtype IOSync a

Instances

• Newtype (IOSync a) _
• Functor IOSync
• Apply IOSync
• Applicative IOSync
• Bind IOSync
• Monad IOSync
• MonadRec IOSync
• (Semigroup a) => Semigroup (IOSync a)
• (Monoid a) => Monoid (IOSync a)
• MonadEff eff IOSync
• MonadError Error IOSync
• MonadThrow Error IOSync
• Alt IOSync
• Plus IOSync
• Alternative IOSync
• MonadZero IOSync

runIOSync' :: forall eff. IOSync ~> (Eff (infinity :: INFINITY | eff))

runIOSync :: IOSync ~> (Eff (infinity :: INFINITY))

class (Monad m) <= MonadIOSync m  where

Members

• liftIOSync :: IOSync ~> m

Instances

• MonadIOSync IOSync
• MonadIOSync IO

data Step a b

The result of a computation: either Loop containing the updated accumulator, or Done containing the final result of the computation.

Constructors

• Loop a
• Done b

Instances

• Functor (Step a)
• Bifunctor Step

class (Monad m) <= MonadRec m  where

This type class captures those monads which support tail recursion in constant stack space.

The tailRecM function takes a step function, and applies that step function recursively until a pure value of type b is found.

Instances are provided for standard monad transformers.

For example:

loopWriter :: Number -> WriterT Sum (Eff (trace :: Trace)) Unit
loopWriter n = tailRecM go n
  where
  go 0 = do
    lift $ trace "Done!"
    pure (Done unit)
  go n = do
    tell $ Sum n
    pure (Loop (n - 1))

Members

• tailRecM :: forall b a. (a -> m (Step a b)) -> a -> m b

Instances

• MonadRec Identity
• MonadRec (Eff eff)
• MonadRec (Either e)

tailRecM3 :: forall d c b a m. MonadRec m => (a -> b -> c -> m (Step { a :: a, b :: b, c :: c } d)) -> a -> b -> c -> m d

Create a tail-recursive function of three arguments which uses constant stack space.

tailRecM2 :: forall c b a m. MonadRec m => (a -> b -> m (Step { a :: a, b :: b } c)) -> a -> b -> m c

Create a tail-recursive function of two arguments which uses constant stack space.

tailRec :: forall b a. (a -> Step a b) -> a -> b

Create a pure tail-recursive function of one argument

For example:

pow :: Number -> Number -> Number
pow n p = tailRec go { accum: 1, power: p }
  where
  go :: _ -> Step _ Number
  go { accum: acc, power: 0 } = Done acc
  go { accum: acc, power: p } = Loop { accum: acc * n, power: p - 1 }

forever :: forall b a m. 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!"

class (MonadZero m) <= MonadPlus m 

The MonadPlus type class has no members of its own but extends MonadZero with an additional law:

• Distributivity: (x <|> y) >>= f == (x >>= f) <|> (y >>= f)

Instances

• MonadPlus Array

class (Monad m, Alternative m) <= MonadZero m 

The MonadZero type class has no members of its own; it just specifies that the type has both Monad and Alternative instances.

Types which have MonadZero instances should also satisfy the following laws:

• Annihilation: empty >>= f = empty

Instances

• MonadZero Array

guard :: forall m. MonadZero m => Boolean -> m Unit

Fail using Plus if a condition does not hold, or succeed using Monad if it does.

For example:

import Prelude
import Control.Monad (bind)
import Control.MonadZero (guard)
import Data.Array ((..))

factors :: Int -> Array Int
factors n = do
  a <- 1..n
  b <- a..n
  guard $ a * b == n
  pure [a, b]

class (Alt f) <= Plus f  where

The Plus type class extends the Alt type class with a value that should be the left and right identity for (<|>).

It is similar to Monoid, except that it applies to types of kind * -> *, like Array or List, rather than concrete types like String or Number.

Plus instances should satisfy the following laws:

• Left identity: empty <|> x == x
• Right identity: x <|> empty == x
• Annihilation: f <$> empty == empty

Members

• empty :: forall a. f a

Instances

• Plus Array

class Bifoldable p  where

Bifoldable represents data structures with two type arguments which can be folded.

A fold for such a structure requires two step functions, one for each type argument. Type class instances should choose the appropriate step function based on the type of the element encountered at each point of the fold.

Default implementations are provided by the following functions:

• bifoldrDefault
• bifoldlDefault
• bifoldMapDefaultR
• bifoldMapDefaultL

Note: some combinations of the default implementations are unsafe to use together - causing a non-terminating mutually recursive cycle. These combinations are documented per function.

Members

• bifoldr :: forall c b a. (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
• bifoldl :: forall c b a. (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
• bifoldMap :: forall b a m. Monoid m => (a -> m) -> (b -> m) -> p a b -> m

Instances

• (Foldable f) => Bifoldable (Clown f)
• (Foldable f) => Bifoldable (Joker f)
• (Bifoldable p) => Bifoldable (Flip p)
• (Bifoldable f, Bifoldable g) => Bifoldable (Product f g)
• (Bifoldable p) => Bifoldable (Wrap p)

bitraverse_ :: forall d c b a f t. Bifoldable t => Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f Unit

Traverse a data structure, accumulating effects using an Applicative functor, ignoring the final result.

bisequence_ :: forall b a f t. Bifoldable t => Applicative f => t (f a) (f b) -> f Unit

Collapse a data structure, collecting effects using an Applicative functor, ignoring the final result.

bifor_ :: forall d c b a f t. Bifoldable t => Applicative f => t a b -> (a -> f c) -> (b -> f d) -> f Unit

A version of bitraverse_ with the data structure as the first argument.

bifold :: forall m t. Bifoldable t => Monoid m => t m m -> m

Fold a data structure, accumulating values in a monoidal type.

biany :: forall c b a t. Bifoldable t => BooleanAlgebra c => (a -> c) -> (b -> c) -> t a b -> c

Test whether a predicate holds at any position in a data structure.

biall :: forall c b a t. Bifoldable t => BooleanAlgebra c => (a -> c) -> (b -> c) -> t a b -> c

Test whether a predicate holds at all positions in a data structure.

class Bifunctor f  where

A Bifunctor is a Functor from the pair category (Type, Type) to Type.

A type constructor with two type arguments can be made into a Bifunctor if both of its type arguments are covariant.

The bimap function maps a pair of functions over the two type arguments of the bifunctor.

Laws:

• Identity: bimap id id == id
• Composition: bimap f1 g1 <<< bimap f2 g2 == bimap (f1 <<< f2) (g1 <<< g2)

Members

• bimap :: forall d c b a. (a -> b) -> (c -> d) -> f a c -> f b d

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

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

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

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

newtype Clown f a b

Make a Functor over the first argument of a Bifunctor

Constructors

• Clown (f a)

Instances

• Newtype (Clown f a b) _
• (Eq (f a)) => Eq (Clown f a b)
• (Ord (f a)) => Ord (Clown f a b)
• (Show (f a)) => Show (Clown f a b)
• Functor (Clown f a)
• (Functor f) => Bifunctor (Clown f)
• (Apply f) => Biapply (Clown f)
• (Applicative f) => Biapplicative (Clown f)

newtype Joker g a b

Make a Functor over the second argument of a Bifunctor

Constructors

• Joker (g b)

Instances

• Newtype (Joker g a b) _
• (Eq (g b)) => Eq (Joker g a b)
• (Ord (g b)) => Ord (Joker g a b)
• (Show (g b)) => Show (Joker g a b)
• (Functor g) => Functor (Joker g a)
• (Functor g) => Bifunctor (Joker g)
• (Apply g) => Biapply (Joker g)
• (Applicative g) => Biapplicative (Joker g)

class (Bifunctor t, Bifoldable t) <= Bitraversable t  where

Bitraversable represents data structures with two type arguments which can be traversed.

A traversal for such a structure requires two functions, one for each type argument. Type class instances should choose the appropriate function based on the type of the element encountered at each point of the traversal.

Default implementations are provided by the following functions:

• bitraverseDefault
• bisequenceDefault

Members

• bitraverse :: forall d c b a f. Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
• bisequence :: forall b a f. Applicative f => t (f a) (f b) -> f (t a b)

Instances

• (Traversable f) => Bitraversable (Clown f)
• (Traversable f) => Bitraversable (Joker f)
• (Bitraversable p) => Bitraversable (Flip p)
• (Bitraversable f, Bitraversable g) => Bitraversable (Product f g)
• (Bitraversable p) => Bitraversable (Wrap p)

rtraverse :: forall f a c b t. Bitraversable t => Applicative f => (b -> f c) -> t a b -> f (t a c)

rfor :: forall f a c b t. Bitraversable t => Applicative f => t a b -> (b -> f c) -> f (t a c)

ltraverse :: forall f a c b t. Bitraversable t => Applicative f => (a -> f c) -> t a b -> f (t c b)

lfor :: forall f a c b t. Bitraversable t => Applicative f => t a b -> (a -> f c) -> f (t c b)

bifor :: forall d c b a f t. Bitraversable t => Applicative f => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)

Traverse a data structure, accumulating effects and results using an Applicative functor.

newtype Const a b

The Const type constructor, which wraps its first type argument and ignores its second. That is, Const a b is isomorphic to a for any b.

Const has some useful instances. For example, the Applicative instance allows us to collect results using a Monoid while ignoring return values.

Constructors

• Const a

Instances

• Newtype (Const a b) _
• (Eq a) => Eq (Const a b)
• (Ord a) => Ord (Const a b)
• (Bounded a) => Bounded (Const a b)
• (Show a) => Show (Const a b)
• Semigroupoid Const
• (Semigroup a) => Semigroup (Const a b)
• (Monoid a) => Monoid (Const a b)
• (Semiring a) => Semiring (Const a b)
• (Ring a) => Ring (Const a b)
• (EuclideanRing a) => EuclideanRing (Const a b)
• (CommutativeRing a) => CommutativeRing (Const a b)
• (Field a) => Field (Const a b)
• (HeytingAlgebra a) => HeytingAlgebra (Const a b)
• (BooleanAlgebra a) => BooleanAlgebra (Const a b)
• Functor (Const a)
• Invariant (Const a)
• Contravariant (Const a)
• (Semigroup a) => Apply (Const a)
• (Semigroup a) => Bind (Const a)
• (Monoid a) => Applicative (Const a)
• Foldable (Const a)
• Traversable (Const a)

class (Decide f, Divisible f) <= Decidable f  where

Decidable is the contravariant analogue of Alternative.

Members

• lose :: forall a. (a -> Void) -> f a

Instances

• Decidable Comparison
• Decidable Equivalence
• Decidable Predicate
• (Monoid r) => Decidable (Op r)

lost :: forall f. Decidable f => f Void

class (Divide f) <= Decide f  where

Decide is the contravariant analogue of Alt.

Members

• choose :: forall c b a. (a -> Either b c) -> f b -> f c -> f a

Instances

• Decide Comparison
• Decide Equivalence
• Decide Predicate
• (Semigroup r) => Decide (Op r)

chosen :: forall b a f. Decide f => f a -> f b -> f (Either a b)

chosen = choose id

class (Contravariant f) <= Divide f  where

Divide is the contravariant analogue of Apply.

For example, to test equality of Points, we can use the Divide instance for Equivalence:

type Point = Tuple Int Int

pointEquiv :: Equivalence Point
pointEquiv = divided defaultEquivalence defaultEquivalence

Members

• divide :: forall c b a. (a -> Tuple b c) -> f b -> f c -> f a

Instances

• Divide Comparison
• Divide Equivalence
• Divide Predicate
• (Semigroup r) => Divide (Op r)

divided :: forall b a f. Divide f => f a -> f b -> f (Tuple a b)

divided = divide id

class (Divide f) <= Divisible f  where

Divisible is the contravariant analogue of Applicative.

Members

• conquer :: forall a. f a

Instances

• Divisible Comparison
• Divisible Equivalence
• Divisible Predicate
• (Monoid r) => Divisible (Op r)

data Either a b

The Either type is used to represent a choice between two types of value.

A common use case for Either is error handling, where Left is used to carry an error value and Right is used to carry a success value.

Constructors

• Left a
• Right b

Instances

• Functor (Either a)

  The Functor instance allows functions to transform the contents of a Right with the <$> operator:

  f <$> Right x == Right (f x)
  

  Left values are untouched:

  f <$> Left y == Left y
  

• Invariant (Either a)
• Bifunctor Either
• Apply (Either e)

  The Apply instance allows functions contained within a Right to transform a value contained within a Right using the (<*>) operator:

  Right f <*> Right x == Right (f x)
  

  Left values are left untouched:

  Left f <*> Right x == Left x
  Right f <*> Left y == Left y
  

  Combining Functor's <$> with Apply's <*> can be used to transform a pure function to take Either-typed arguments so f :: a -> b -> c becomes f :: Either l a -> Either l b -> Either l c:

  f <$> Right x <*> Right y == Right (f x y)
  

  The Left-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Left means the whole result becomes Left also, taking the first Left value found:

  f <$> Left x <*> Right y == Left x
  f <$> Right x <*> Left y == Left y
  f <$> Left x <*> Left y == Left x
  

• Applicative (Either e)

  The Applicative instance enables lifting of values into Either with the pure function:

  pure x :: Either _ _ == Right x
  

  Combining Functor's <$> with Apply's <*> and Applicative's pure can be used to pass a mixture of Either and non-Either typed values to a function that does not usually expect them, by using pure for any value that is not already Either typed:

  f <$> Right x <*> pure y == Right (f x y)
  

  Even though pure = Right it is recommended to use pure in situations like this as it allows the choice of Applicative to be changed later without having to go through and replace Right with a new constructor.

• Alt (Either e)

  The Alt instance allows for a choice to be made between two Either values with the <|> operator, where the first Right encountered is taken.

  Right x <|> Right y == Right x
  Left x <|> Right y == Right y
  Left x <|> Left y == Left y
  

• Bind (Either e)

  The Bind instance allows sequencing of Either values and functions that return an Either by using the >>= operator:

  Left x >>= f = Left x
  Right x >>= f = f x
  

• Monad (Either e)

  The Monad instance guarantees that there are both Applicative and Bind instances for Either. This also enables the do syntactic sugar:

  do
    x' <- x
    y' <- y
    pure (f x' y')
  

  Which is equivalent to:

  x >>= (\x' -> y >>= (\y' -> pure (f x' y')))
  

• Extend (Either e)

  The Extend instance allows sequencing of Either values and functions that accept an Either and return a non-Either result using the <<= operator.

  f <<= Left x = Left x
  f <<= Right x = Right (f (Right x))
  

• (Show a, Show b) => Show (Either a b)

  The Show instance allows Either values to be rendered as a string with show whenever there is an Show instance for both type the Either can contain.

• (Eq a, Eq b) => Eq (Either a b)

  The Eq instance allows Either values to be checked for equality with == and inequality with /= whenever there is an Eq instance for both types the Either can contain.

• (Eq a) => Eq1 (Either a)
• (Ord a, Ord b) => Ord (Either a b)

  The Ord instance allows Either values to be compared with compare, >, >=, < and <= whenever there is an Ord instance for both types the Either can contain.

  Any Left value is considered to be less than a Right value.

• (Ord a) => Ord1 (Either a)
• (Bounded a, Bounded b) => Bounded (Either a b)
• Foldable (Either a)
• Bifoldable Either
• Traversable (Either a)
• Bitraversable Either
• (Semiring b) => Semiring (Either a b)
• (Semigroup b) => Semigroup (Either a b)

isRight :: forall b a. Either a b -> Boolean

Returns true when the Either value was constructed with Right.

isLeft :: forall b a. Either a b -> Boolean

Returns true when the Either value was constructed with Left.

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

A partial function that extracts the value from the Right data constructor. Passing a Left to fromRight will throw an error at runtime.

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

A partial function that extracts the value from the Left data constructor. Passing a Right to fromLeft will throw an error at runtime.

either :: forall c b a. (a -> c) -> (b -> c) -> Either a b -> c

Takes two functions and an Either value, if the value is a Left the inner value is applied to the first function, if the value is a Right the inner value is applied to the second function.

either f g (Left x) == f x
either f g (Right y) == g y

class Eq1 f  where

The Eq type class represents type constructors with decidable equality.

Members

• eq1 :: forall a. Eq a => f a -> f a -> Boolean

Instances

• Eq1 Array

notEq1 :: forall a f. Eq1 f => Eq a => f a -> f a -> Boolean

data Exists :: (Type -> Type) -> Type

This type constructor can be used to existentially quantify over a type of kind Type.

Specifically, the type Exists f is isomorphic to the existential type exists a. f a.

Existential types can be encoded using universal types (forall) for endofunctors in more general categories. The benefit of this library is that, by using the FFI, we can create an efficient representation of the existential by simply hiding type information.

For example, consider the type exists s. Tuple s (s -> Tuple s a) which represents infinite streams of elements of type a.

This type can be constructed by creating a type constructor StreamF as follows:

data StreamF a s = StreamF s (s -> Tuple s a)

We can then define the type of streams using Exists:

type Stream a = Exists (StreamF a)

runExists :: forall r f. (forall a. f a -> r) -> Exists f -> r

The runExists function is used to eliminate a value of type Exists f. The rank 2 type ensures that the existentially-quantified type does not escape its scope. Since the function is required to work for any type a, it will work for the existentially-quantified type.

For example, we can write a function to obtain the head of a stream by using runExists as follows:

head :: forall a. Stream a -> a
head = runExists head'
  where
  head' :: forall s. StreamF a s -> a
  head' (StreamF s f) = snd (f s)

mkExists :: forall a f. f a -> Exists f

The mkExists function is used to introduce a value of type Exists f, by providing a value of type f a, for some type a which will be hidden in the existentially-quantified type.

For example, to create a value of type Stream Number, we might use mkExists as follows:

nats :: Stream Number
nats = mkExists $ StreamF 0 (\n -> Tuple (n + 1) n)

class Foldable f  where

Foldable represents data structures which can be folded.

• foldr folds a structure from the right
• foldl folds a structure from the left
• foldMap folds a structure by accumulating values in a Monoid

Default implementations are provided by the following functions:

• foldrDefault
• foldlDefault
• foldMapDefaultR
• foldMapDefaultL

Note: some combinations of the default implementations are unsafe to use together - causing a non-terminating mutually recursive cycle. These combinations are documented per function.

Members

• foldr :: forall b a. (a -> b -> b) -> b -> f a -> b
• foldl :: forall b a. (b -> a -> b) -> b -> f a -> b
• foldMap :: forall m a. Monoid m => (a -> m) -> f a -> m

Instances

• Foldable Array
• Foldable Maybe
• Foldable First
• Foldable Last
• Foldable Additive
• Foldable Dual
• Foldable Disj
• Foldable Conj
• Foldable Multiplicative

traverse_ :: forall m f b a. Applicative m => Foldable f => (a -> m b) -> f a -> m Unit

Traverse a data structure, performing some effects encoded by an Applicative functor at each value, ignoring the final result.

For example:

traverse_ print [1, 2, 3]

sum :: forall f a. Foldable f => Semiring a => f a -> a

Find the sum of the numeric values in a data structure.

sequence_ :: forall m f a. Applicative m => Foldable f => f (m a) -> m Unit

Perform all of the effects in some data structure in the order given by the Foldable instance, ignoring the final result.

For example:

sequence_ [ trace "Hello, ", trace " world!" ]

product :: forall f a. Foldable f => Semiring a => f a -> a

Find the product of the numeric values in a data structure.

or :: forall f a. Foldable f => HeytingAlgebra a => f a -> a

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

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

Combines a collection of elements using the Alt operation.

notElem :: forall f a. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is not an element of a data structure.

minimumBy :: forall f a. Foldable f => (a -> a -> Ordering) -> f a -> Maybe a

Find the smallest element of a structure, according to a given comparison function. The comparison function should represent a total ordering (see the Ord type class laws); if it does not, the behaviour is undefined.

minimum :: forall f a. Ord a => Foldable f => f a -> Maybe a

Find the smallest element of a structure, according to its Ord instance.

maximumBy :: forall f a. Foldable f => (a -> a -> Ordering) -> f a -> Maybe a

Find the largest element of a structure, according to a given comparison function. The comparison function should represent a total ordering (see the Ord type class laws); if it does not, the behaviour is undefined.

maximum :: forall f a. Ord a => Foldable f => f a -> Maybe a

Find the largest element of a structure, according to its Ord instance.

intercalate :: forall m f. 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_ :: forall m f b a. Applicative m => Foldable f => f a -> (a -> m b) -> m Unit

A version of traverse_ with its arguments flipped.

This can be useful when running an action written using do notation for every element in a data structure:

For example:

for_ [1, 2, 3] \n -> do
  print n
  trace "squared is"
  print (n * n)

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

Fold a data structure, accumulating values in some Monoid.

findMap :: forall f b a. Foldable f => (a -> Maybe b) -> f a -> Maybe b

Try to find an element in a data structure which satisfies a predicate mapping.

find :: forall f a. Foldable f => (a -> Boolean) -> f a -> Maybe a

Try to find an element in a data structure which satisfies a predicate.

elem :: forall f a. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is an element of a data structure.

any :: forall f b a. 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.

and :: forall f a. 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.

all :: forall f b a. 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.

on :: forall c b a. (b -> b -> c) -> (a -> b) -> a -> a -> c

The on function is used to change the domain of a binary operator.

For example, we can create a function which compares two records based on the values of their x properties:

compareX :: forall r. { x :: Number | r } -> { x :: Number | r } -> Ordering
compareX = compare `on` _.x

newtype Compose f g a

Compose f g is the composition of the two functors f and g.

Constructors

• Compose (f (g a))

Instances

• Newtype (Compose f g a) _
• (Eq1 f, Eq1 g) => Eq1 (Compose f g)
• (Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)
• (Ord1 f, Ord1 g) => Ord1 (Compose f g)
• (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)
• (Show (f (g a))) => Show (Compose f g a)
• (Functor f, Functor g) => Functor (Compose f g)
• (Apply f, Apply g) => Apply (Compose f g)
• (Applicative f, Applicative g) => Applicative (Compose f g)
• (Foldable f, Foldable g) => Foldable (Compose f g)
• (Traversable f, Traversable g) => Traversable (Compose f g)
• (Alt f, Functor g) => Alt (Compose f g)
• (Plus f, Functor g) => Plus (Compose f g)
• (Alternative f, Applicative g) => Alternative (Compose f g)

class Contravariant f  where

A Contravariant functor can be seen as a way of changing the input type of a consumer of input, in contrast to the standard covariant Functor that can be seen as a way of changing the output type of a producer of output.

Contravariant instances should satisfy the following laws:

• Identity (>$<) id = id
• Composition (f >$<) <<< (g >$<) = (>$<) (g <<< f)

Members

• cmap :: forall b a. (b -> a) -> f a -> f b

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

Operator alias for Data.Functor.Contravariant.cmap (left-associative / precedence 4)

Operator alias for Data.Functor.Contravariant.cmapFlipped (left-associative / precedence 4)

newtype Coproduct f g a

Coproduct f g is the coproduct of two functors f and g

Constructors

• Coproduct (Either (f a) (g a))

Instances

• Newtype (Coproduct f g a) _
• (Eq1 f, Eq1 g, Eq a) => Eq (Coproduct f g a)
• (Eq1 f, Eq1 g) => Eq1 (Coproduct f g)
• (Ord1 f, Ord1 g, Ord a) => Ord (Coproduct f g a)
• (Ord1 f, Ord1 g) => Ord1 (Coproduct f g)
• (Show (f a), Show (g a)) => Show (Coproduct f g a)
• (Functor f, Functor g) => Functor (Coproduct f g)
• (Extend f, Extend g) => Extend (Coproduct f g)
• (Comonad f, Comonad g) => Comonad (Coproduct f g)
• (Foldable f, Foldable g) => Foldable (Coproduct f g)
• (Traversable f, Traversable g) => Traversable (Coproduct f g)

right :: forall a g f. g a -> Coproduct f g a

Right injection

left :: forall a g f. f a -> Coproduct f g a

Left injection

coproduct :: forall b a g f. (f a -> b) -> (g a -> b) -> Coproduct f g a -> b

Eliminate a coproduct by providing eliminators for the left and right components

Operator alias for Data.Functor.Coproduct.Coproduct (right-associative / precedence 6)

class Invariant f  where

A type of functor that can be used to adapt the type of a wrapped function where the parameterised type occurs in both the positive and negative position, for example, F (a -> a).

An Invariant instance should satisfy the following laws:

• Identity: imap id id = id
• Composition: imap g1 g2 <<< imap f1 f2 = imap (g1 <<< f1) (f2 <<< g2)

Members

• imap :: forall b a. (a -> b) -> (b -> a) -> f a -> f b

Instances

• Invariant (Function a)
• Invariant Array

newtype Mu f

Mu f is the least fixed point of a functor f, when it exists.

Constructors

• In (f (Mu f))

Instances

• Newtype (Mu f) _
• (Eq1 f) => Eq (Mu f)

  To implement Eq, we require f to have higher-kinded equality.

• (Eq1 f, Ord1 f) => Ord (Mu f)

  To implement Ord, we require f to have higher-kinded comparison.

• (Show (f TacitString), Functor f) => Show (Mu f)

  Show is compositional, so we only f to be able to show a single layer of structure.

unroll :: forall f. Mu f -> f (Mu f)

transMu :: forall g f. Functor g => (forall a. f a -> g a) -> Mu f -> Mu g

Rewrites a tree along a natural transformation.

roll :: forall f. f (Mu f) -> Mu f

newtype Nu f

Nu f is the greatest fixed point of the functor f, when it exists.

Instances

• Newtype (Nu f) _

newtype Product f g a

Product f g is the product of the two functors f and g.

Constructors

• Product (Tuple (f a) (g a))

Instances

• Newtype (Product f g a) _
• (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a)
• (Eq1 f, Eq1 g) => Eq1 (Product f g)
• (Ord1 f, Ord1 g, Ord a) => Ord (Product f g a)
• (Ord1 f, Ord1 g) => Ord1 (Product f g)
• (Show (f a), Show (g a)) => Show (Product f g a)
• (Functor f, Functor g) => Functor (Product f g)
• (Foldable f, Foldable g) => Foldable (Product f g)
• (Traversable f, Traversable g) => Traversable (Product f g)
• (Apply f, Apply g) => Apply (Product f g)
• (Applicative f, Applicative g) => Applicative (Product f g)
• (Bind f, Bind g) => Bind (Product f g)
• (Monad f, Monad g) => Monad (Product f g)

Operator alias for Data.Functor.Product.Product (right-associative / precedence 6)

type Abelian a b = Group a => CommutativeSemigroup a => b

class (Semigroup g) <= CommutativeSemigroup g 

A CommutativeSemigroup is a Semigroup with a commutative operation. Instances must satisfy the following law in addition to the group laws:

• Commutativity: forall x, y. x <> y = y <> x

Instances

• CommutativeSemigroup Void
• CommutativeSemigroup Unit
• (CommutativeSemigroup g) => CommutativeSemigroup (Dual g)
• (Ring r) => CommutativeSemigroup (Additive r)

class (Monoid g) <= Group g  where

A Group is a Monoid with inverses. Instances must satisfy the following law in addition to the monoid laws:

• Inverse: forall x. ginverse x <> x = mempty = x <> ginverse x

Members

• ginverse :: g -> g

Instances

• Group Unit
• (Group g) => Group (Dual g)
• (Ring r) => Group (Additive r)

newtype Identity a

Constructors

• Identity a

Instances

• Newtype (Identity a) _
• (Eq a) => Eq (Identity a)
• (Ord a) => Ord (Identity a)
• (Bounded a) => Bounded (Identity a)
• (HeytingAlgebra a) => HeytingAlgebra (Identity a)
• (BooleanAlgebra a) => BooleanAlgebra (Identity a)
• (Semigroup a) => Semigroup (Identity a)
• (Monoid a) => Monoid (Identity a)
• (Semiring a) => Semiring (Identity a)
• (EuclideanRing a) => EuclideanRing (Identity a)
• (Ring a) => Ring (Identity a)
• (CommutativeRing a) => CommutativeRing (Identity a)
• (Field a) => Field (Identity a)
• (Lazy a) => Lazy (Identity a)
• (Show a) => Show (Identity a)
• Eq1 Identity
• Ord1 Identity
• Functor Identity
• Invariant Identity
• Alt Identity
• Apply Identity
• Applicative Identity
• Bind Identity
• Monad Identity
• Extend Identity
• Comonad Identity
• Foldable Identity
• Traversable Identity

odd :: Int -> Boolean

The negation of even.

odd 0 == false
odd 1 == false

even :: Int -> Boolean

Returns whether an Int is an even number.

even 0 == true
even 1 == false

zshr :: Int -> Int -> Int

Bitwise zero-fill shift right.

shr :: Int -> Int -> Int

Bitwise shift right.

shl :: Int -> Int -> Int

Bitwise shift left.

Operator alias for Data.Int.Bits.or (left-associative / precedence 10)

Operator alias for Data.Int.Bits.xor (left-associative / precedence 10)

Operator alias for Data.Int.Bits.and (left-associative / precedence 10)

data Lazy :: Type -> Type

Lazy a represents lazily-computed values of type a.

A lazy value is computed at most once - the result is saved after the first computation, and subsequent attempts to read the value simply return the saved value.

Lazy values can be created with defer, or by using the provided type class instances.

Lazy values can be evaluated by using the force function.

Instances

• (Semiring a) => Semiring (Lazy a)
• (Ring a) => Ring (Lazy a)
• (CommutativeRing a) => CommutativeRing (Lazy a)
• (EuclideanRing a) => EuclideanRing (Lazy a)
• (Field a) => Field (Lazy a)
• (Eq a) => Eq (Lazy a)
• (Ord a) => Ord (Lazy a)
• (Bounded a) => Bounded (Lazy a)
• (Semigroup a) => Semigroup (Lazy a)
• (Monoid a) => Monoid (Lazy a)
• (HeytingAlgebra a) => HeytingAlgebra (Lazy a)
• (BooleanAlgebra a) => BooleanAlgebra (Lazy a)
• Functor Lazy
• Invariant Lazy
• Apply Lazy
• Applicative Lazy
• Bind Lazy
• Monad Lazy
• Extend Lazy
• Comonad Lazy
• (Show a) => Show (Lazy a)
• Lazy (Lazy a)

force :: forall a. Lazy a -> a

Force evaluation of a Lazy value.

defer :: forall a. (Unit -> a) -> Lazy a

Defer a computation, creating a Lazy value.

newtype Leibniz a b

Two types are equal if they are equal in all contexts.

Constructors

• Leibniz (forall f. f a -> f b)

Instances

• Semigroupoid Leibniz
• Category Leibniz

Operator alias for Data.Leibniz.Leibniz (non-associative / precedence 4)

data List a

Constructors

• Nil

Instances

• (Show a) => Show (List a)
• (Eq a) => Eq (List a)
• Eq1 List
• (Ord a) => Ord (List a)
• Ord1 List
• Semigroup (List a)
• Monoid (List a)
• Functor List
• Foldable List
• Unfoldable List
• Traversable List
• Apply List
• Applicative List
• Bind List
• Monad List
• Alt List
• Plus List
• Alternative List
• MonadZero List
• MonadPlus List
• Extend List

Operator alias for Data.List.Types.Cons (right-associative / precedence 6)

data Maybe a

The Maybe type is used to represent optional values and can be seen as something like a type-safe null, where Nothing is null and Just x is the non-null value x.

Constructors

• Nothing
• Just a

Instances

• Functor Maybe

  The Functor instance allows functions to transform the contents of a Just with the <$> operator:

  f <$> Just x == Just (f x)
  

  Nothing values are left untouched:

  f <$> Nothing == Nothing
  

• Apply Maybe

  The Apply instance allows functions contained within a Just to transform a value contained within a Just using the apply operator:

  Just f <*> Just x == Just (f x)
  

  Nothing values are left untouched:

  Just f <*> Nothing == Nothing
  Nothing <*> Just x == Nothing
  

  Combining Functor's <$> with Apply's <*> can be used transform a pure function to take Maybe-typed arguments so f :: a -> b -> c becomes f :: Maybe a -> Maybe b -> Maybe c:

  f <$> Just x <*> Just y == Just (f x y)
  

  The Nothing-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Nothing means the whole result becomes Nothing also:

  f <$> Nothing <*> Just y == Nothing
  f <$> Just x <*> Nothing == Nothing
  f <$> Nothing <*> Nothing == Nothing
  

• Applicative Maybe

  The Applicative instance enables lifting of values into Maybe with the pure or return function (return is an alias for pure):

  pure x :: Maybe _ == Just x
  return x :: Maybe _ == Just x
  

  Combining Functor's <$> with Apply's <*> and Applicative's pure can be used to pass a mixture of Maybe and non-Maybe typed values to a function that does not usually expect them, by using pure for any value that is not already Maybe typed:

  f <$> Just x <*> pure y == Just (f x y)
  

  Even though pure = Just it is recommended to use pure in situations like this as it allows the choice of Applicative to be changed later without having to go through and replace Just with a new constructor.

• Alt Maybe

  The Alt instance allows for a choice to be made between two Maybe values with the <|> operator, where the first Just encountered is taken.

  Just x <|> Just y == Just x
  Nothing <|> Just y == Just y
  Nothing <|> Nothing == Nothing
  

• Plus Maybe

  The Plus instance provides a default Maybe value:

  empty :: Maybe _ == Nothing
  

• Alternative Maybe

  The Alternative instance guarantees that there are both Applicative and Plus instances for Maybe.

• Bind Maybe

  The Bind instance allows sequencing of Maybe values and functions that return a Maybe by using the >>= operator:

  Just x >>= f = f x
  Nothing >>= f = Nothing
  

• Monad Maybe

  The Monad instance guarantees that there are both Applicative and Bind instances for Maybe. This also enables the do syntactic sugar:

  do
    x' <- x
    y' <- y
    pure (f x' y')
  

  Which is equivalent to:

  x >>= (\x' -> y >>= (\y' -> pure (f x' y')))
  

• MonadZero Maybe
• Extend Maybe

  The Extend instance allows sequencing of Maybe values and functions that accept a Maybe a and return a non-Maybe result using the <<= operator.

  f <<= Nothing = Nothing
  f <<= Just x = Just (f x)
  

• Invariant Maybe
• (Semigroup a) => Semigroup (Maybe a)

  The Semigroup instance enables use of the operator <> on Maybe values whenever there is a Semigroup instance for the type the Maybe contains. The exact behaviour of <> depends on the "inner" Semigroup instance, but generally captures the notion of appending or combining things.

  Just x <> Just y = Just (x <> y)
  Just x <> Nothing = Just x
  Nothing <> Just y = Just y
  Nothing <> Nothing = Nothing
  

• (Semigroup a) => Monoid (Maybe a)
• (Eq a) => Eq (Maybe a)

  The Eq instance allows Maybe values to be checked for equality with == and inequality with /= whenever there is an Eq instance for the type the Maybe contains.

• Eq1 Maybe
• (Ord a) => Ord (Maybe a)

  The Ord instance allows Maybe values to be compared with compare, >, >=, < and <= whenever there is an Ord instance for the type the Maybe contains.

  Nothing is considered to be less than any Just value.

• Ord1 Maybe
• (Bounded a) => Bounded (Maybe a)
• (Show a) => Show (Maybe a)

  The Show instance allows Maybe values to be rendered as a string with show whenever there is an Show instance for the type the Maybe contains.

maybe' :: forall b a. (Unit -> b) -> (a -> b) -> Maybe a -> b

Similar to maybe but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard maybe has to evaluate the default value before returning the result, whereas here the value is only computed when the Maybe is known to be Nothing.

maybe' (\_ -> x) f Nothing == x
maybe' (\_ -> x) f (Just y) == f y

maybe :: forall b a. b -> (a -> b) -> Maybe a -> b

Takes a default value, a function, and a Maybe value. If the Maybe value is Nothing the default value is returned, otherwise the function is applied to the value inside the Just and the result is returned.

maybe x f Nothing == x
maybe x f (Just y) == f y

isNothing :: forall a. Maybe a -> Boolean

Returns true when the Maybe value is Nothing.

isJust :: forall a. Maybe a -> Boolean

Returns true when the Maybe value was constructed with Just.

fromMaybe' :: forall a. (Unit -> a) -> Maybe a -> a

Similar to fromMaybe but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromMaybe has to evaluate the default value before returning the result, whereas here the value is only computed when the Maybe is known to be Nothing.

fromMaybe' (\_ -> x) Nothing == x
fromMaybe' (\_ -> x) (Just y) == y

fromMaybe :: forall a. a -> Maybe a -> a

Takes a default value, and a Maybe value. If the Maybe value is Nothing the default value is returned, otherwise the value inside the Just is returned.

fromMaybe x Nothing == x
fromMaybe x (Just y) == y

fromJust :: forall a. Partial => Maybe a -> a

A partial function that extracts the value from the Just data constructor. Passing Nothing to fromJust will throw an error at runtime.

newtype First a

Monoid returning the first (left-most) non-Nothing value.

First (Just x) <> First (Just y) == First (Just x)
First Nothing <> First (Just y) == First (Just y)
First Nothing <> Nothing == First Nothing
mempty :: First _ == First Nothing

Constructors

• First (Maybe a)

Instances

• Newtype (First a) _
• (Eq a) => Eq (First a)
• Eq1 First
• (Ord a) => Ord (First a)
• Ord1 First
• (Bounded a) => Bounded (First a)
• Functor First
• Invariant First
• Apply First
• Applicative First
• Bind First
• Monad First
• Extend First
• (Show a) => Show (First a)
• Semigroup (First a)
• Monoid (First a)

newtype Last a

Monoid returning the last (right-most) non-Nothing value.

Last (Just x) <> Last (Just y) == Last (Just y)
Last (Just x) <> Nothing == Last (Just x)
Last Nothing <> Nothing == Last Nothing
mempty :: Last _ == Last Nothing

Constructors

• Last (Maybe a)

Instances

• Newtype (Last a) _
• (Eq a) => Eq (Last a)
• Eq1 Last
• (Ord a) => Ord (Last a)
• Ord1 Last
• (Bounded a) => Bounded (Last a)
• Functor Last
• Invariant Last
• Apply Last
• Applicative Last
• Bind Last
• Monad Last
• Extend Last
• (Show a) => Show (Last a)
• Semigroup (Last a)
• Monoid (Last a)

class (Ring r) <= LeftModule x r | x -> r

Left modules over rings.

Instances must satisfy the following laws:

• Left distributivity: r ^* (x ^+ y) = r ^* x ^+ r ^* y
• Left distributivity: (r + s) ^* x = r ^* x ^+ s ^* x
• Left compatibility: (r * s) ^* x = r ^* (s ^* x)
• Left identity: one ^* x = x

Instances

• (Ring a) => LeftModule Unit a