Module

Stuff

Package
purescript-stuff
Repository
rightfold/purescript-stuff

#type (\/) Source

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

#log Source

log :: forall m. MonadIOSync m => String -> m Unit

#logError Source

logError :: forall m. MonadIOSync m => String -> m Unit

#logInfo Source

logInfo :: forall m. MonadIOSync m => String -> m Unit

#logWarning Source

logWarning :: forall m. MonadIOSync m => String -> m Unit

#dlmap Source

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

#drmap Source

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

#(\) Source

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

#(\\) Source

Operator alias for Stuff.compose2 (right-associative / precedence 9)

#(\\\) Source

Operator alias for Stuff.compose3 (right-associative / precedence 9)

#(\\\\) Source

Operator alias for Stuff.compose4 (right-associative / precedence 9)

#(\\\\\) Source

Operator alias for Stuff.compose5 (right-associative / precedence 9)

#compose2 Source

compose2 :: forall t100 t101 t102 t98 t99. Semigroupoid t99 => t99 t101 t100 -> (t98 -> t99 t102 t101) -> t98 -> t99 t102 t100

#compose3 Source

compose3 :: forall t86 t90 t91 t92 t93 t94. Semigroupoid t91 => t91 t93 t92 -> (t86 -> t90 -> t91 t94 t93) -> t86 -> t90 -> t91 t94 t92

#compose4 Source

compose4 :: forall t70 t74 t78 t79 t80 t81 t82. Semigroupoid t79 => t79 t81 t80 -> (t70 -> t74 -> t78 -> t79 t82 t81) -> t70 -> t74 -> t78 -> t79 t82 t80

#compose5 Source

compose5 :: forall t50 t54 t58 t62 t63 t64 t65 t66. Semigroupoid t63 => t63 t65 t64 -> (t50 -> t54 -> t58 -> t62 -> t63 t66 t65) -> t50 -> t54 -> t58 -> t62 -> t63 t66 t64

Re-exports from Control.Alt

#Alt Source

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

#(<|>) Source

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

Re-exports from Control.Alternative

#Alternative Source

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

Re-exports from Control.Apply

#lift5 Source

lift5 :: forall a b c d e f g. 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 Source

lift4 :: forall a b c d e f. 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 Source

lift3 :: forall a b c d f. 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 Source

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

Re-exports from Control.Biapplicative

#Biapplicative Source

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 a b. a -> b -> w a b

Re-exports from Control.Biapply

#Biapply Source

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 Source

bilift3 :: forall w a b c d e f g h. 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 Source

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

Lift a function of two arguments.

#(<<*>>) Source

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

#(<<*) Source

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

#(<<$>>) Source

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

#(*>>) Source

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

Re-exports from Control.Comonad

#Comonad Source

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

Re-exports from Control.Extend

#Extend Source

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 b a. (w a -> b) -> w a -> w b

Instances

#duplicate Source

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

Duplicate a comonadic context.

duplicate is dual to Control.Bind.join.

#(=>>) Source

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

#(=>=) Source

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

#(=<=) Source

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

#(<<=) Source

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

Re-exports from Control.Monad.Aff.Class

#liftAff

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

Re-exports from Control.Monad.Eff.Class

#liftEff

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

Re-exports from Control.Monad.Eff.Exception

#Error Source

data Error :: Type

The type of JavaScript errors

Instances

Re-exports from Control.Monad.IO

#IO

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'

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

#runIO

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

#launchIO

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

Re-exports from Control.Monad.IO.Class

#MonadIO

class (Monad m) <= MonadIO m  where

Members

  • liftIO :: IO ~> m

Instances

  • MonadIO IO

Re-exports from Control.Monad.IOSync

#IOSync

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'

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

#runIOSync

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

Re-exports from Control.Monad.IOSync.Class

#MonadIOSync

class (Monad m) <= MonadIOSync m  where

Members

  • liftIOSync :: IOSync ~> m

Instances

  • MonadIOSync IOSync
  • MonadIOSync IO

Re-exports from Control.Monad.Rec.Class

#Step Source

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

Instances

#MonadRec Source

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

Instances

#tailRecM3 Source

tailRecM3 :: forall m a b c d. 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 Source

tailRecM2 :: forall m a b c. 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 Source

tailRec :: forall a b. (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 Source

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!"

Re-exports from Control.MonadPlus

#MonadPlus Source

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

Re-exports from Control.MonadZero

#MonadZero Source

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

#guard Source

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]

Re-exports from Control.Plus

#Plus Source

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

Instances

Re-exports from Data.Bifoldable

#Bifoldable Source

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 a b c. (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
  • bifoldl :: forall a b c. (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
  • bifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> p a b -> m

Instances

#bitraverse_ Source

bitraverse_ :: forall t f a b c d. 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_ Source

bisequence_ :: forall t f a b. 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_ Source

bifor_ :: forall t f a b c d. 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 Source

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

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

#biany Source

biany :: forall t a b c. 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 Source

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

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

Re-exports from Data.Bifunctor

#Bifunctor Source

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 a b c d. (a -> b) -> (c -> d) -> f a c -> f b d

#rmap Source

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.

#lmap Source

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.

Re-exports from Data.Bifunctor.Clown

#Clown Source

newtype Clown f a b

Make a Functor over the first argument of a Bifunctor

Constructors

Instances

Re-exports from Data.Bifunctor.Joker

#Joker Source

newtype Joker g a b

Make a Functor over the second argument of a Bifunctor

Constructors

Instances

Re-exports from Data.Bitraversable

#Bitraversable Source

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

Instances

#rtraverse Source

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

#rfor Source

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

#ltraverse Source

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

#lfor Source

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

#bifor Source

bifor :: forall t f a b c d. 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.

Re-exports from Data.Const

#Const Source

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

Instances

Re-exports from Data.Decidable

#Decidable Source

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

Decidable is the contravariant analogue of Alternative.

Members

Instances

#lost Source

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

Re-exports from Data.Decide

#Decide Source

class (Divide f) <= Decide f  where

Decide is the contravariant analogue of Alt.

Members

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

Instances

#chosen Source

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

chosen = choose id

Re-exports from Data.Divide

#Divide Source

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 a b c. (a -> Tuple b c) -> f b -> f c -> f a

Instances

#divided Source

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

divided = divide id

Re-exports from Data.Divisible

#Divisible Source

class (Divide f) <= Divisible f  where

Divisible is the contravariant analogue of Applicative.

Members

Instances

Re-exports from Data.Either

#Either Source

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

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 Source

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

Returns true when the Either value was constructed with Right.

#isLeft Source

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

Returns true when the Either value was constructed with Left.

#fromRight Source

fromRight :: forall a b. 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 Source

fromLeft :: forall a b. 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 Source

either :: forall a b c. (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

Re-exports from Data.Eq

#Eq1 Source

class Eq1 f  where

The Eq type class represents type constructors with decidable equality.

Members

Instances

#notEq1 Source

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

Re-exports from Data.Exists

#Exists Source

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 Source

runExists :: forall f r. (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 Source

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

Re-exports from Data.Foldable

#Foldable Source

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 a b. (a -> b -> b) -> b -> f a -> b
  • foldl :: forall a b. (b -> a -> b) -> b -> f a -> b
  • foldMap :: forall a m. Monoid m => (a -> m) -> f a -> m

Instances

#traverse_ Source

traverse_ :: forall a b f m. 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 Source

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

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

#sequence_ Source

sequence_ :: forall a f m. 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 Source

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

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

#or Source

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

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

Combines a collection of elements using the Alt operation.

#notElem Source

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

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

#minimumBy Source

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

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

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

#maximumBy Source

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

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

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

#intercalate Source

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_ Source

for_ :: forall a b f m. 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 Source

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

Fold a data structure, accumulating values in some Monoid.

#findMap Source

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

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

#find Source

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

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

#elem Source

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

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

#any Source

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.

#and Source

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.

#all Source

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.

Re-exports from Data.Function

#on Source

on :: forall a b c. (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

Re-exports from Data.Functor.Compose

#Compose Source

newtype Compose f g a

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

Constructors

Instances

Re-exports from Data.Functor.Contravariant

#Contravariant Source

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 a b. (b -> a) -> f a -> f b

#coerce Source

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

#(>$<) Source

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

#(>#<) Source

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

Re-exports from Data.Functor.Coproduct

#Coproduct Source

newtype Coproduct f g a

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

Constructors

Instances

#right Source

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

Right injection

#left Source

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

Left injection

#coproduct Source

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

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

Re-exports from Data.Functor.Coproduct.Nested

#type (<\/>) Source

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

Re-exports from Data.Functor.Invariant

#Invariant Source

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 a b. (a -> b) -> (b -> a) -> f a -> f b

Instances

Re-exports from Data.Functor.Mu

#Mu Source

newtype Mu f

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

Constructors

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 Source

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

#transMu Source

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

Rewrites a tree along a natural transformation.

#roll Source

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

Re-exports from Data.Functor.Nu

#Nu Source

newtype Nu f

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

Instances

Re-exports from Data.Functor.Product

#Product Source

newtype Product f g a

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

Constructors

Instances

Re-exports from Data.Functor.Product.Nested

#type (</\>) Source

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

Re-exports from Data.Group

#Abelian Source

type Abelian a b = Group a => Commutative a => b

An Abelian group is a group with a commutative operation.

#Group Source

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

Instances

Re-exports from Data.Identity

Re-exports from Data.Int

#odd Source

odd :: Int -> Boolean

The negation of even.

odd 0 == false
odd 1 == false

#even Source

even :: Int -> Boolean

Returns whether an Int is an even number.

even 0 == true
even 1 == false

Re-exports from Data.Int.Bits

#zshr Source

zshr :: Int -> Int -> Int

Bitwise zero-fill shift right.

#shr Source

shr :: Int -> Int -> Int

Bitwise shift right.

#shl Source

shl :: Int -> Int -> Int

Bitwise shift left.

#(.|.) Source

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

#(.^.) Source

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

#(.&.) Source

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

Re-exports from Data.Lazy

#Lazy Source

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

#force Source

force :: forall a. Lazy a -> a

Force evaluation of a Lazy value.

#defer Source

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

Defer a computation, creating a Lazy value.

Re-exports from Data.Leibniz

#Leibniz Source

newtype Leibniz a b

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

Constructors

Instances

#type (~) Source

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

Re-exports from Data.List

#List

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)

Re-exports from Data.Maybe

#Maybe Source

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

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' Source

maybe' :: forall a b. (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 Source

maybe :: forall a b. 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 Source

isNothing :: forall a. Maybe a -> Boolean

Returns true when the Maybe value is Nothing.

#isJust Source

isJust :: forall a. Maybe a -> Boolean

Returns true when the Maybe value was constructed with Just.

#fromMaybe' Source

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 Source

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 Source

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.

Re-exports from Data.Maybe.First

#First Source

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

Instances

Re-exports from Data.Maybe.Last

#Last Source

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

Instances

Re-exports from Data.Module

#LeftModule Source

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

#RightModule Source

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

Right modules over rings.

Instances must satisfy the following laws:

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

Instances

#mnegateR Source

mnegateR :: forall x r. RightModule x r => x -> x

#mnegateL Source

mnegateL :: forall x r. LeftModule x r => x -> x

#(^-) Source

Operator alias for Data.Module.msubL (left-associative / precedence 6)

#(^+) Source

Operator alias for Data.Module.maddL (left-associative / precedence 6)

#(^*) Source

Operator alias for Data.Module.mmulL (left-associative / precedence 7)

#(-^) Source

Operator alias for Data.Module.msubR (left-associative / precedence 6)

#(+^) Source

Operator alias for Data.Module.maddR (left-associative / precedence 6)

#(*^) Source

Operator alias for Data.Module.mmulR (left-associative / precedence 7)

Re-exports from Data.Monoid

#Monoid Source

class (Semigroup m) <= Monoid m  where

A Monoid is a Semigroup with a value mempty, which is both a left and right unit for the associative operation <>:

forall x. mempty <> x = x <> mempty = x

Monoids are commonly used as the result of fold operations, where <> is used to combine individual results, and mempty gives the result of folding an empty collection of elements.

Members

Instances

Re-exports from Data.Monoid.Additive

#Additive Source

newtype Additive a

Monoid and semigroup for semirings under addition.

Additive x <> Additive y == Additive (x + y)
mempty :: Additive _ == Additive zero

Constructors

Instances

Re-exports from Data.Monoid.Alternate

#Alternate Source

newtype Alternate f a

Monoid and semigroup instances corresponding to Plus and Alt instances for f

Alternate fx <> Alternate fy == Alternate (fx <|> fy)
mempty :: Alternate _ == Alternate empty

Constructors

Instances

Re-exports from Data.Monoid.Conj

#Conj Source

newtype Conj a

Monoid under conjuntion.

Conj x <> Conj y == Conj (x && y)
mempty :: Conj _ == Conj top

Constructors

Instances

Re-exports from Data.Monoid.Disj

#Disj Source

newtype Disj a

Monoid under disjuntion.

Disj x <> Disj y == Disj (x || y)
mempty :: Disj _ == Disj bottom

Constructors

Instances

Re-exports from Data.Monoid.Dual

#Dual Source

newtype Dual a

The dual of a monoid.

Dual x <> Dual y == Dual (y <> x)
mempty :: Dual _ == Dual mempty

Constructors

Instances

Re-exports from Data.Monoid.Endo

#Endo Source

newtype Endo a

Monoid of endomorphisms under composition.

Composes of functions of type a -> a:

Endo f <> Endo g == Endo (f <<< g)
mempty :: Endo _ == Endo id

Constructors

Instances

Re-exports from Data.Monoid.Multiplicative

#Multiplicative Source

newtype Multiplicative a

Monoid and semigroup for semirings under multiplication.

Multiplicative x <> Multiplicative y == Multiplicative (x * y)
mempty :: Multiplicative _ == Multiplicative one

Constructors

Instances

Re-exports from Data.Newtype

#Newtype Source

class Newtype t a | t -> a where

A type class for newtypes to enable convenient wrapping and unwrapping, and the use of the other functions in this module.

The compiler can derive instances of Newtype automatically:

newtype EmailAddress = EmailAddress String

derive instance newtypeEmailAddress :: Newtype EmailAddress _

Note that deriving for Newtype instances requires that the type be defined as newtype rather than data declaration (even if the data structurally fits the rules of a newtype), and the use of a wildcard for the wrapped type.

Instances must obey the following laws:

unwrap <<< wrap = id
wrap <<< unwrap = id

Members

#underF2 Source

underF2 :: forall f g t a s b. Functor f => Functor g => Newtype t a => Newtype s b => (a -> t) -> (f t -> f t -> g s) -> f a -> f a -> g b

Much like under2, but where the lifted binary function operates on values in a Functor.

#underF Source

underF :: forall f g t a s b. Functor f => Functor g => Newtype t a => Newtype s b => (a -> t) -> (f t -> g s) -> f a -> g b

Much like under, but where the lifted function operates on values in a Functor:

newtype EmailAddress = EmailAddress String
derive instance newtypeEmailAddress :: Newtype EmailAddress _

isValid :: EmailAddress -> Boolean
isValid x = false -- imagine a slightly less strict predicate here

findValidEmailString :: Array String -> Maybe String
findValidEmailString = underF EmailAddress (Foldable.find isValid)

The above example also demonstrates that the functor type is polymorphic here too, the input is an Array but the result is a Maybe.

#under2 Source

under2 :: forall t a s b. Newtype t a => Newtype s b => (a -> t) -> (t -> t -> s) -> a -> a -> b

The opposite of over2: lowers a binary function that operates on Newtyped values to operate on the wrapped value instead.

#under Source

under :: forall t a s b. Newtype t a => Newtype s b => (a -> t) -> (t -> s) -> a -> b

The opposite of over: lowers a function that operates on Newtyped values to operate on the wrapped value instead.

newtype Degrees = Degrees Number
derive instance newtypeDegrees :: Newtype Degrees _

newtype NormalDegrees = NormalDegrees Number
derive instance newtypeNormalDegrees :: Newtype NormalDegrees _

normaliseDegrees :: Degrees -> NormalDegrees
normaliseDegrees (Degrees deg) = NormalDegrees (deg % 360.0)

asNormalDegrees :: Number -> Number
asNormalDegrees = under Degrees normaliseDegrees

As with over the Newtype is polymorphic, as illustrated in the example above - both Degrees and NormalDegrees are instances of Newtype, so even though normaliseDegrees changes the result type we can still put a Number in and get a Number out via under.

#overF2 Source

overF2 :: forall f g t a s b. Functor f => Functor g => Newtype t a => Newtype s b => (a -> t) -> (f a -> f a -> g b) -> f t -> f t -> g s

Much like over2, but where the lifted binary function operates on values in a Functor.

#overF Source

overF :: forall f g t a s b. Functor f => Functor g => Newtype t a => Newtype s b => (a -> t) -> (f a -> g b) -> f t -> g s

Much like over, but where the lifted function operates on values in a Functor:

findLabel :: String -> Array Label -> Maybe Label
findLabel s = overF Label (Foldable.find (_ == s))

The above example also demonstrates that the functor type is polymorphic here too, the input is an Array but the result is a Maybe.

#over2 Source

over2 :: forall t a s b. Newtype t a => Newtype s b => (a -> t) -> (a -> a -> b) -> t -> t -> s

Lifts a binary function to operate over newtypes.

newtype Meter = Meter Int
derive newtype instance newtypeMeter :: Newtype Meter _
newtype SquareMeter = SquareMeter Int
derive newtype instance newtypeSquareMeter :: Newtype SquareMeter _

area :: Meter -> Meter -> SquareMeter
area = over2 Meter (*)

The above example also demonstrates that the return type is polymorphic here too.

#over Source

over :: forall t a s b. Newtype t a => Newtype s b => (a -> t) -> (a -> b) -> t -> s

Lifts a function operate over newtypes. This can be used to lift a function to manipulate the contents of a single newtype, somewhat like map does for a Functor:

newtype Label = Label String
derive instance newtypeLabel :: Newtype Label _

toUpperLabel :: Label -> Label
toUpperLabel = over Label String.toUpper

But the result newtype is polymorphic, meaning the result can be returned as an alternative newtype:

newtype UppercaseLabel = UppercaseLabel String
derive instance newtypeUppercaseLabel :: Newtype UppercaseLabel _

toUpperLabel' :: Label -> UppercaseLabel
toUpperLabel' = over Label String.toUpper

#ala Source

ala :: forall f t a s b. Functor f => Newtype t a => Newtype s b => (a -> t) -> ((b -> s) -> f t) -> f a

This combinator is for when you have a higher order function that you want to use in the context of some newtype - foldMap being a common example:

ala Additive foldMap [1,2,3,4] -- 10
ala Multiplicative foldMap [1,2,3,4] -- 24
ala Conj foldMap [true, false] -- false
ala Disj foldMap [true, false] -- true

Re-exports from Data.Op

#Op Source

newtype Op a b

The opposite of the function category.

Constructors

  • Op (b -> a)

Instances

Re-exports from Data.Ord

#Ord1 Source

class (Eq1 f) <= Ord1 f  where

The Ord1 type class represents totally ordered type constructors.

Members

Instances

#signum Source

signum :: forall a. Ord a => Ring a => a -> a

The sign function; always evaluates to either one or negate one. For any x, we should have signum x * abs x == x.

#abs Source

abs :: forall a. Ord a => Ring a => a -> a

The absolute value function. abs x is defined as if x >= zero then x else negate x.

Re-exports from Data.Ord.Max

#Max Source

newtype Max a

Provides a Semigroup based on the max function. If the type has a Bounded instance, then a Monoid instance is provided too. For example:

unwrap (Max 5 <> Max 6) = 6
mempty :: Max Ordering = Max LT

Constructors

Instances

Re-exports from Data.Ord.Min

#Min Source

newtype Min a

Provides a Semigroup based on the min function. If the type has a Bounded instance, then a Monoid instance is provided too. For example:

unwrap (Min 5 <> Min 6) = 5
mempty :: Min Ordering = Min GT

Constructors

Instances

Re-exports from Data.Profunctor

#Profunctor

class Profunctor p  where

A Profunctor is a Functor from the pair category (Type^op, Type) to Type.

In other words, a Profunctor is a type constructor of two type arguments, which is contravariant in its first argument and covariant in its second argument.

The dimap function can be used to map functions over both arguments simultaneously.

A straightforward example of a profunctor is the function arrow (->).

Laws:

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

Members

  • dimap :: forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d

Instances

  • Profunctor Function

#arr

arr :: forall a b p. Category p => Profunctor p => (a -> b) -> p a b

Lift a pure function into any Profunctor which is also a Category.

Re-exports from Data.Profunctor.Choice

#Choice

class (Profunctor p) <= Choice p  where

The Choice class extends Profunctor with combinators for working with sum types.

left and right lift values in a Profunctor to act on the Left and Right components of a sum, respectively.

Looking at Choice through the intuition of inputs and outputs yields the following type signature:

left ::  forall input output a. p input output -> p (Either input a) (Either output a)
right :: forall input output a. p input output -> p (Either a input) (Either a output)

If we specialize the profunctor p to the function arrow, we get the following type signatures:

left ::  forall input output a. (input -> output) -> (Either input a) -> (Either output a)
right :: forall input output a. (input -> output) -> (Either a input) -> (Either a output)

When the profunctor is Function application, left allows you to map a function over the left side of an Either, and right maps it over the right side (same as map would do).

Members

  • left :: forall a b c. p a b -> p (Either a c) (Either b c)
  • right :: forall a b c. p b c -> p (Either a b) (Either a c)

Instances

  • Choice Function

#(|||)

Operator alias for Data.Profunctor.Choice.fanin (right-associative / precedence 2)

#(+++)

Operator alias for Data.Profunctor.Choice.splitChoice (right-associative / precedence 2)

Re-exports from Data.Profunctor.Closed

#Closed

class (Profunctor p) <= Closed p  where

The Closed class extends the Profunctor class to work with functions.

Members

  • closed :: forall a b x. p a b -> p (x -> a) (x -> b)

Instances

  • Closed Function

Re-exports from Data.Profunctor.Costar

#Costar

newtype Costar f b a

Costar turns a Functor into a Profunctor "backwards".

Costar f is also the co-Kleisli category for f.

Constructors

  • Costar (f b -> a)

Instances

  • Newtype (Costar f a b) _
  • (Extend f) => Semigroupoid (Costar f)
  • (Comonad f) => Category (Costar f)
  • Functor (Costar f a)
  • Invariant (Costar f a)
  • Apply (Costar f a)
  • Applicative (Costar f a)
  • Bind (Costar f a)
  • Monad (Costar f a)
  • Distributive (Costar f a)
  • (Functor f) => Profunctor (Costar f)
  • (Comonad f) => Strong (Costar f)
  • (Functor f) => Costrong (Costar f)
  • (Applicative f) => Cochoice (Costar f)
  • (Functor f) => Closed (Costar f)

Re-exports from Data.Profunctor.Costrong

#Costrong

class (Profunctor p) <= Costrong p  where

The Costrong class provides the dual operations of the Strong class.

Members

  • unfirst :: forall a b c. p (Tuple a c) (Tuple b c) -> p a b
  • unsecond :: forall a b c. p (Tuple a b) (Tuple a c) -> p b c

Re-exports from Data.Profunctor.Star

#Star

newtype Star f a b

Star turns a Functor into a Profunctor.

Star f is also the Kleisli category for f

Constructors

  • Star (a -> f b)

Instances

  • Newtype (Star f a b) _
  • (Bind f) => Semigroupoid (Star f)
  • (Monad f) => Category (Star f)
  • (Functor f) => Functor (Star f a)
  • (Invariant f) => Invariant (Star f a)
  • (Apply f) => Apply (Star f a)
  • (Applicative f) => Applicative (Star f a)
  • (Bind f) => Bind (Star f a)
  • (Monad f) => Monad (Star f a)
  • (Alt f) => Alt (Star f a)
  • (Plus f) => Plus (Star f a)
  • (Alternative f) => Alternative (Star f a)
  • (MonadZero f) => MonadZero (Star f a)
  • (MonadPlus f) => MonadPlus (Star f a)
  • (Distributive f) => Distributive (Star f a)
  • (Functor f) => Profunctor (Star f)
  • (Functor f) => Strong (Star f)
  • (Applicative f) => Choice (Star f)
  • (Distributive f) => Closed (Star f)

Re-exports from Data.Profunctor.Strong

#Strong

class (Profunctor p) <= Strong p  where

The Strong class extends Profunctor with combinators for working with product types.

first and second lift values in a Profunctor to act on the first and second components of a Tuple, respectively.

Another way to think about Strong is to piggyback on the intuition of inputs and outputs. Rewriting the type signature in this light then yields:

first ::  forall input output a. p input output -> p (Tuple input a) (Tuple output a)
second :: forall input output a. p input output -> p (Tuple a input) (Tuple a output)

If we specialize the profunctor p to the function arrow, we get the following type signatures, which may look a bit more familiar:

first ::  forall input output a. (input -> output) -> (Tuple input a) -> (Tuple output a)
second :: forall input output a. (input -> output) -> (Tuple a input) -> (Tuple a output)

So, when the profunctor is Function application, first essentially applies your function to the first element of a Tuple, and second applies it to the second element (same as map would do).

Members

  • first :: forall a b c. p a b -> p (Tuple a c) (Tuple b c)
  • second :: forall a b c. p b c -> p (Tuple a b) (Tuple a c)

Instances

  • Strong Function

#(***)

Operator alias for Data.Profunctor.Strong.splitStrong (right-associative / precedence 3)

#(&&&)

Operator alias for Data.Profunctor.Strong.fanout (right-associative / precedence 3)

Re-exports from Data.Semigroup.Commutative

#Commutative Source

class (Semigroup g) <= Commutative g 

A Commutative 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

Re-exports from Data.Symbol

#SProxy Source

data SProxy (sym :: Symbol)

A value-level proxy for a type-level symbol.

Constructors

#IsSymbol Source

class IsSymbol (sym :: Symbol)  where

A class for known symbols

Members

Instances

#reifySymbol Source

reifySymbol :: forall r. String -> (forall sym. IsSymbol sym => SProxy sym -> r) -> r

Re-exports from Data.Traversable

#Traversable Source

class (Functor t, Foldable t) <= Traversable t  where

Traversable represents data structures which can be traversed, accumulating results and effects in some Applicative functor.

  • traverse runs an action for every element in a data structure, and accumulates the results.
  • sequence runs the actions contained in a data structure, and accumulates the results.

The traverse and sequence functions should be compatible in the following sense:

  • traverse f xs = sequence (f <$> xs)
  • sequence = traverse id

Traversable instances should also be compatible with the corresponding Foldable instances, in the following sense:

  • foldMap f = runConst <<< traverse (Const <<< f)

Default implementations are provided by the following functions:

  • traverseDefault
  • sequenceDefault

Members

Instances

#scanr Source

scanr :: forall a b f. Traversable f => (a -> b -> b) -> b -> f a -> f b

Fold a data structure from the right, keeping all intermediate results instead of only the final result. Note that the initial value does not appear in the result (unlike Haskell's Prelude.scanr).

scanr (+) 0  [1,2,3] = [1,3,6]
scanr (flip (-)) 10 [1,2,3] = [4,5,7]

#scanl Source

scanl :: forall a b f. Traversable f => (b -> a -> b) -> b -> f a -> f b

Fold a data structure from the left, keeping all intermediate results instead of only the final result. Note that the initial value does not appear in the result (unlike Haskell's Prelude.scanl).

scanl (+) 0  [1,2,3] = [1,3,6]
scanl (-) 10 [1,2,3] = [9,7,4]

#for Source

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

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
  return (n * n)

Re-exports from Data.Tuple

#Tuple Source

data Tuple a b

A simple product type for wrapping a pair of component values.

Constructors

Instances

#uncurry Source

uncurry :: forall a b c. (a -> b -> c) -> Tuple a b -> c

Turn a function of two arguments into a function that expects a tuple.

#swap Source

swap :: forall a b. Tuple a b -> Tuple b a

Exchange the first and second components of a tuple.

#snd Source

snd :: forall a b. Tuple a b -> b

Returns the second component of a tuple.

#fst Source

fst :: forall a b. Tuple a b -> a

Returns the first component of a tuple.

#curry Source

curry :: forall a b c. (Tuple a b -> c) -> a -> b -> c

Turn a function that expects a tuple into a function of two arguments.

Re-exports from Data.Tuple.Nested

#(/\) Source

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

Shorthand for constructing n-tuples as nested pairs. a /\ b /\ c /\ d /\ unit becomes Tuple a (Tuple b (Tuple c (Tuple d unit)))

#type (/\) Source

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

Shorthand for constructing n-tuple types as nested pairs. forall a b c d. a /\ b /\ c /\ d /\ Unit becomes forall a b c d. Tuple a (Tuple b (Tuple c (Tuple d Unit)))

Re-exports from Debug.Trace

#traceShowM Source

traceShowM :: forall m a. DebugWarning => Show a => Monad m => a -> m a

Same as traceAnyM but only for Showable values

#traceShowA Source

traceShowA :: forall a b. DebugWarning => Show b => Applicative a => b -> a Unit

Log a Showable value to the console for debugging purposes and then return the unit value of the Applicative a.

#traceShow Source

traceShow :: forall a b. DebugWarning => Show a => a -> (Unit -> b) -> b

Log a Showable value to the console for debugging purposes and then return a value.

#traceAnyM Source

traceAnyM :: forall m a. DebugWarning => Monad m => a -> m a

Log any PureScript value to the console and return it in Monad useful when one has monadic chains

mbArray :: Maybe (Array Int)
foo :: Int
foo = fromMaybe zero
  $ mbArray
  >>= traceAnyM
  >>= head
  >>= traceAnyM

#traceAnyA Source

traceAnyA :: forall a b. DebugWarning => Applicative a => b -> a Unit

Log any PureScript value to the console and return the unit value of the Applicative a.

#traceAny Source

traceAny :: forall a b. DebugWarning => a -> (Unit -> b) -> b

Log any PureScript value to the console for debugging purposes and then return a value. This will log the value's underlying representation for low-level debugging.

#traceA Source

traceA :: forall a. DebugWarning => Applicative a => String -> a Unit

Log a message to the console for debugging purposes and then return the unit value of the Applicative a.

For example:

doSomething = do
  traceA "Hello"
  ... some value or computation ...

#trace Source

trace :: forall a. DebugWarning => String -> (Unit -> a) -> a

Log a message to the console for debugging purposes and then return a value. The return value is thunked so it is not evaluated until after the message has been printed, to preserve a predictable console output.

For example:

doSomething = trace "Hello" \_ -> ... some value or computation ...

#spy Source

spy :: forall a. DebugWarning => a -> a

Log any value and return it

Re-exports from Partial

#crashWith Source

crashWith :: forall a. Partial => String -> a

A partial function which crashes on any input with the specified message.

#crash Source

crash :: forall a. Partial => a

A partial function which crashes on any input with a default message.

Re-exports from Partial.Unsafe

#unsafePartial Source

unsafePartial :: forall a. (Partial => a) -> a

Discharge a partiality constraint, unsafely.

#unsafeCrashWith Source

unsafeCrashWith :: forall a. String -> a

A function which crashes with the specified error message.

Re-exports from Prelude

#Void Source

newtype Void

An uninhabited data type.

Void is useful to eliminate the possibility of a value being created. For example, a value of type Either Void Boolean can never have a Left value created in PureScript.

Instances

#Unit Source

data Unit :: Type

The Unit type has a single inhabitant, called unit. It represents values with no computational content.

Unit is often used, wrapped in a monadic type constructor, as the return type of a computation where only the effects are important.

Instances

#Ordering Source

data Ordering

The Ordering data type represents the three possible outcomes of comparing two values:

LT - The first value is less than the second. GT - The first value is greater than the second. EQ - The first value is equal to the second.

Constructors

Instances

#Applicative Source

class (Apply f) <= Applicative f  where

The Applicative type class extends the Apply type class with a pure function, which can be used to create values of type f a from values of type a.

Where Apply provides the ability to lift functions of two or more arguments to functions whose arguments are wrapped using f, and Functor provides the ability to lift functions of one argument, pure can be seen as the function which lifts functions of zero arguments. That is, Applicative functors support a lifting operation for any number of function arguments.

Instances must satisfy the following laws in addition to the Apply laws:

  • Identity: (pure id) <*> v = v
  • Composition: pure (<<<) <*> f <*> g <*> h = f <*> (g <*> h)
  • Homomorphism: (pure f) <*> (pure x) = pure (f x)
  • Interchange: u <*> (pure y) = (pure (_ $ y)) <*> u

Members

  • pure :: forall a. a -> f a

Instances

#Apply Source

class (Functor f) <= Apply f  where

The Apply class provides the (<*>) which is used to apply a function to an argument under a type constructor.

Apply can be used to lift functions of two or more arguments to work on values wrapped with the type constructor f. It might also be understood in terms of the lift2 function:

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

(<*>) is recovered from lift2 as lift2 ($). That is, (<*>) lifts the function application operator ($) to arguments wrapped with the type constructor f.

Instances must satisfy the following law in addition to the Functor laws:

  • Associative composition: (<<<) <$> f <*> g <*> h = f <*> (g <*> h)

Formally, Apply represents a strong lax semi-monoidal endofunctor.

Members

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

Instances

#Bind Source

class (Apply m) <= Bind m  where

The Bind type class extends the Apply type class with a "bind" operation (>>=) which composes computations in sequence, using the return value of one computation to determine the next computation.

The >>= operator can also be expressed using do notation, as follows:

x >>= f = do y <- x
             f y

where the function argument of f is given the name y.

Instances must satisfy the following law in addition to the Apply laws:

  • Associativity: (x >>= f) >>= g = x >>= (\k -> f k >>= g)

Associativity tells us that we can regroup operations which use do notation so that we can unambiguously write, for example:

do x <- m1
   y <- m2 x
   m3 x y

Members

  • bind :: forall a b. m a -> (a -> m b) -> m b

Instances

#BooleanAlgebra Source

class (HeytingAlgebra a) <= BooleanAlgebra a 

The BooleanAlgebra type class represents types that behave like boolean values.

Instances should satisfy the following laws in addition to the HeytingAlgebra law:

  • Excluded middle:
    • a || not a = tt

Instances

#Bounded Source

class (Ord a) <= Bounded a  where

The Bounded type class represents totally ordered types that have an upper and lower boundary.

Instances should satisfy the following law in addition to the Ord laws:

  • Bounded: bottom <= a <= top

Members

Instances

#Category Source

class (Semigroupoid a) <= Category a  where

Categorys consist of objects and composable morphisms between them, and as such are Semigroupoids, but unlike semigroupoids must have an identity element.

Instances must satisfy the following law in addition to the Semigroupoid law:

  • Identity: id <<< p = p <<< id = p

Members

  • id :: forall t. a t t

Instances

#CommutativeRing Source

class (Ring a) <= CommutativeRing a 

The CommutativeRing class is for rings where multiplication is commutative.

Instances must satisfy the following law in addition to the Ring laws:

  • Commutative multiplication: a * b = b * a

Instances

#Discard Source

class Discard a  where

A class for types whose values can safely be discarded in a do notation block.

An example is the Unit type, since there is only one possible value which can be returned.

Members

  • discard :: forall f b. Bind f => f a -> (a -> f b) -> f b

Instances

#Eq Source

class Eq a  where

The Eq type class represents types which support decidable equality.

Eq instances should satisfy the following laws:

  • Reflexivity: x == x = true
  • Symmetry: x == y = y == x
  • Transitivity: if x == y and y == z then x == z

Note: The Number type is not an entirely law abiding member of this class due to the presence of NaN, since NaN /= NaN. Additionally, computing with Number can result in a loss of precision, so sometimes values that should be equivalent are not.

Members

Instances

#EuclideanRing Source

class (CommutativeRing a) <= EuclideanRing a  where

The EuclideanRing class is for commutative rings that support division. The mathematical structure this class is based on is sometimes also called a Euclidean domain.

Instances must satisfy the following laws in addition to the Ring laws:

  • Integral domain: one /= zero, and if a and b are both nonzero then so is their product a * b
  • Euclidean function degree:
    • Nonnegativity: For all nonzero a, degree a >= 0
    • Quotient/remainder: For all a and b, where b is nonzero, let q = a / b and r = a `mod` b; then a = q*b + r, and also either r = zero or degree r < degree b
  • Submultiplicative euclidean function:
    • For all nonzero a and b, degree a <= degree (a * b)

The behaviour of division by zero is unconstrained by these laws, meaning that individual instances are free to choose how to behave in this case. Similarly, there are no restrictions on what the result of degree zero is; it doesn't make sense to ask for degree zero in the same way that it doesn't make sense to divide by zero, so again, individual instances may choose how to handle this case.

For any EuclideanRing which is also a Field, one valid choice for degree is simply const 1. In fact, unless there's a specific reason not to, Field types should normally use this definition of degree.

The Unit instance is provided for backwards compatibility, but it is not law-abiding, because Unit fails to form an integral domain. This instance will be removed in a future release.

Members

Instances

#Field Source

class (EuclideanRing a) <= Field a 

The Field class is for types that are commutative fields.

Instances must satisfy the following law in addition to the EuclideanRing laws:

  • Non-zero multiplicative inverse: a `mod` b = zero for all a and b

The Unit instance is provided for backwards compatibility, but it is not law-abiding, because Unit does not obey the EuclideanRing laws. This instance will be removed in a future release.

Instances

#Functor Source

class Functor f  where

A Functor is a type constructor which supports a mapping operation map.

map can be used to turn functions a -> b into functions f a -> f b whose argument and return types use the type constructor f to represent some computational context.

Instances must satisfy the following laws:

  • Identity: map id = id
  • Composition: map (f <<< g) = map f <<< map g

Members

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

Instances

#HeytingAlgebra Source

class HeytingAlgebra a  where

The HeytingAlgebra type class represents types that are bounded lattices with an implication operator such that the following laws hold:

  • Associativity:
    • a || (b || c) = (a || b) || c
    • a && (b && c) = (a && b) && c
  • Commutativity:
    • a || b = b || a
    • a && b = b && a
  • Absorption:
    • a || (a && b) = a
    • a && (a || b) = a
  • Idempotent:
    • a || a = a
    • a && a = a
  • Identity:
    • a || ff = a
    • a && tt = a
  • Implication:
    • a `implies` a = tt
    • a && (a `implies` b) = a && b
    • b && (a `implies` b) = b
    • a `implies` (b && c) = (a `implies` b) && (a `implies` c)
  • Complemented:
    • not a = a `implies` ff

Members

Instances

#Monad Source

class (Applicative m, Bind m) <= Monad m 

The Monad type class combines the operations of the Bind and Applicative type classes. Therefore, Monad instances represent type constructors which support sequential composition, and also lifting of functions of arbitrary arity.

Instances must satisfy the following laws in addition to the Applicative and Bind laws:

  • Left Identity: pure x >>= f = f x
  • Right Identity: x >>= pure = x

Instances

#Ord Source

class (Eq a) <= Ord a  where

The Ord type class represents types which support comparisons with a total order.

Ord instances should satisfy the laws of total orderings:

  • Reflexivity: a <= a
  • Antisymmetry: if a <= b and b <= a then a = b
  • Transitivity: if a <= b and b <= c then a <= c

Members

Instances

#Ring Source

class (Semiring a) <= Ring a  where

The Ring class is for types that support addition, multiplication, and subtraction operations.

Instances must satisfy the following law in addition to the Semiring laws:

  • Additive inverse: a - a = (zero - a) + a = zero

Members

  • sub :: a -> a -> a

Instances

#Semigroup Source

class Semigroup a  where

The Semigroup type class identifies an associative operation on a type.

Instances are required to satisfy the following law:

  • Associativity: (x <> y) <> z = x <> (y <> z)

One example of a Semigroup is String, with (<>) defined as string concatenation.

Members

Instances

#Semigroupoid Source

class Semigroupoid a  where

A Semigroupoid is similar to a Category but does not require an identity element id, just composable morphisms.

Semigroupoids must satisfy the following law:

  • Associativity: p <<< (q <<< r) = (p <<< q) <<< r

One example of a Semigroupoid is the function type constructor (->), with (<<<) defined as function composition.

Members

  • compose :: forall b c d. a c d -> a b c -> a b d

Instances

#Semiring Source

class Semiring a  where

The Semiring class is for types that support an addition and multiplication operation.

Instances must satisfy the following laws:

  • Commutative monoid under addition:
    • Associativity: (a + b) + c = a + (b + c)
    • Identity: zero + a = a + zero = a
    • Commutative: a + b = b + a
  • Monoid under multiplication:
    • Associativity: (a * b) * c = a * (b * c)
    • Identity: one * a = a * one = a
  • Multiplication distributes over addition:
    • Left distributivity: a * (b + c) = (a * b) + (a * c)
    • Right distributivity: (a + b) * c = (a * c) + (b * c)
  • Annihilation: zero * a = a * zero = zero

Note: The Number and Int types are not fully law abiding members of this class hierarchy due to the potential for arithmetic overflows, and in the case of Number, the presence of NaN and Infinity values. The behaviour is unspecified in these cases.

Members

Instances

#Show Source

class Show a  where

The Show type class represents those types which can be converted into a human-readable String representation.

While not required, it is recommended that for any expression x, the string show x be executable PureScript code which evaluates to the same value as the expression x.

Members

Instances

#whenM Source

whenM :: forall m. Monad m => m Boolean -> m Unit -> m Unit

Perform a monadic action when a condition is true, where the conditional value is also in a monadic context.

#when Source

when :: forall m. Applicative m => Boolean -> m Unit -> m Unit

Perform a applicative action when a condition is true.

#void Source

void :: forall f a. Functor f => f a -> f Unit

The void function is used to ignore the type wrapped by a Functor, replacing it with Unit and keeping only the type information provided by the type constructor itself.

void is often useful when using do notation to change the return type of a monadic computation:

main = forE 1 10 \n -> void do
  print n
  print (n * n)

#unlessM Source

unlessM :: forall m. Monad m => m Boolean -> m Unit -> m Unit

Perform a monadic action unless a condition is true, where the conditional value is also in a monadic context.

#unless Source

unless :: forall m. Applicative m => Boolean -> m Unit -> m Unit

Perform a applicative action unless a condition is true.

#unit Source

unit :: Unit

unit is the sole inhabitant of the Unit type.

#otherwise Source

otherwise :: Boolean

An alias for true, which can be useful in guard clauses:

max x y | x >= y    = x
        | otherwise = y

#notEq Source

notEq :: forall a. Eq a => a -> a -> Boolean

notEq tests whether one value is not equal to another. Shorthand for not (eq x y).

#negate Source

negate :: forall a. Ring a => a -> a

negate x can be used as a shorthand for zero - x.

#min Source

min :: forall a. Ord a => a -> a -> a

Take the minimum of two values. If they are considered equal, the first argument is chosen.

#max Source

max :: forall a. Ord a => a -> a -> a

Take the maximum of two values. If they are considered equal, the first argument is chosen.

#liftM1 Source

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

#liftA1 Source

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

#lcm Source

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

The least common multiple of two values.

#join Source

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

Collapse two applications of a monadic type constructor into one.

#ifM Source

ifM :: forall a m. Bind m => m Boolean -> m a -> m a -> m a

Execute a monadic action if a condition holds.

For example:

main = ifM ((< 0.5) <$> random)
         (trace "Heads")
         (trace "Tails")

#gcd Source

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

The greatest common divisor of two values.

#flip Source

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

Flips the order of the arguments to a function of two arguments.

flip const 1 2 = const 2 1 = 2

#flap Source

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

Apply a value in a computational context to a value in no context.

Generalizes flip.

longEnough :: String -> Bool
hasSymbol :: String -> Bool
hasDigit :: String -> Bool
password :: String

validate :: String -> List Bool
validate = flap [longEnough, hasSymbol, hasDigit]
flap (-) 3 4 == 1
threeve <$> Just 1 <@> 'a' <*> Just true == Just (threeve 1 'a' true)

#const Source

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

Returns its first argument and ignores its second.

const 1 "hello" = 1

#comparing Source

comparing :: forall a b. Ord b => (a -> b) -> (a -> a -> Ordering)

Compares two values by mapping them to a type with an Ord instance.

#clamp Source

clamp :: forall a. Ord a => a -> a -> a -> a

Clamp a value between a minimum and a maximum. For example:

let f = clamp 0 10
f (-5) == 0
f 5    == 5
f 15   == 10

#between Source

between :: forall a. Ord a => a -> a -> a -> Boolean

Test whether a value is between a minimum and a maximum (inclusive). For example:

let f = between 0 10
f 0    == true
f (-5) == false
f 5    == true
f 10   == true
f 15   == false

#ap Source

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

ap provides a default implementation of (<*>) for any Monad, without using (<*>) as provided by the Apply-Monad superclass relationship.

ap can therefore be used to write Apply instances as follows:

instance applyF :: Apply F where
  apply = ap

#absurd Source

absurd :: forall a. Void -> a

#(||) Source

Operator alias for Data.HeytingAlgebra.disj (right-associative / precedence 2)

#(>>>) Source

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

#(>>=) Source

Operator alias for Control.Bind.bind (left-associative / precedence 1)

#(>=>) Source

Operator alias for Control.Bind.composeKleisli (right-associative / precedence 1)

#(>=) Source

Operator alias for Data.Ord.greaterThanOrEq (left-associative / precedence 4)

#(>) Source

Operator alias for Data.Ord.greaterThan (left-associative / precedence 4)

#(==) Source

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

#(=<<) Source

Operator alias for Control.Bind.bindFlipped (right-associative / precedence 1)

#(<@>) Source

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

#(<>) Source

Operator alias for Data.Semigroup.append (right-associative / precedence 5)

#(<=<) Source

Operator alias for Control.Bind.composeKleisliFlipped (right-associative / precedence 1)

#(<=) Source

Operator alias for Data.Ord.lessThanOrEq (left-associative / precedence 4)

#(<<<) Source

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

#(<*>) Source

Operator alias for Control.Apply.apply (left-associative / precedence 4)

#(<*) Source

Operator alias for Control.Apply.applyFirst (left-associative / precedence 4)

#(<$>) Source

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

#(<$) Source

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

#(<#>) Source

Operator alias for Data.Functor.mapFlipped (left-associative / precedence 1)

#(<) Source

Operator alias for Data.Ord.lessThan (left-associative / precedence 4)

#(/=) Source

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

#(/) Source

Operator alias for Data.EuclideanRing.div (left-associative / precedence 7)

#(-) Source

Operator alias for Data.Ring.sub (left-associative / precedence 6)

#(+) Source

Operator alias for Data.Semiring.add (left-associative / precedence 6)

#(*>) Source

Operator alias for Control.Apply.applySecond (left-associative / precedence 4)

#(*) Source

Operator alias for Data.Semiring.mul (left-associative / precedence 7)

#(&&) Source

Operator alias for Data.HeytingAlgebra.conj (right-associative / precedence 3)

#($>) Source

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

#($) Source

Operator alias for Data.Function.apply (right-associative / precedence 0)

Applies a function to an argument: the reverse of (#).

length $ groupBy productCategory $ filter isInStock $ products

is equivalent to:

length (groupBy productCategory (filter isInStock products))

Or another alternative equivalent, applying chain of composed functions to a value:

length <<< groupBy productCategory <<< filter isInStock $ products

#(#) Source

Operator alias for Data.Function.applyFlipped (left-associative / precedence 1)

Applies an argument to a function: the reverse of ($).

products # filter isInStock # groupBy productCategory # length

is equivalent to:

length (groupBy productCategory (filter isInStock products))

Or another alternative equivalent, applying a value to a chain of composed functions:

products # filter isInStock >>> groupBy productCategory >>> length

#type (~>) Source

Operator alias for Data.NaturalTransformation.NaturalTransformation (right-associative / precedence 4)

Re-exports from Type.Proxy

#Proxy3 Source

data Proxy3 (a :: Type -> Type -> Type)

Value proxy for kind Type -> Type -> Type types.

Constructors

Instances

#Proxy2 Source

data Proxy2 (a :: Type -> Type)

Value proxy for kind Type -> Type types.

Constructors

Instances

Re-exports from Unsafe.Coerce

#unsafeCoerce Source

unsafeCoerce :: forall a b. a -> b

A highly unsafe function, which can be used to persuade the type system that any type is the same as any other type. When using this function, it is your (that is, the caller's) responsibility to ensure that the underlying representation for both types is the same.

One application for this function is to avoid doing work that you know is a no-op because of newtypes. For example, if you have an Array (Conj a) and you want an Array (Disj a), you could do Data.Array.map (runConj >>> Disj), but this performs an unnecessary traversal. unsafeCoerce accomplishes the same for free.

It is highly recommended to define specializations of this function rather than using it as-is. For example:

mapConjToDisj :: forall a. Array (Conj a) -> Array (Disj a)
mapConjToDisj = unsafeCoerce

This way, you won't have any nasty surprises due to the inferred type being different to what you expected.

Modules
Stuff