Module

MasonPrelude

Package
purescript-mason-prelude
Repository
ursi/purescript-mason-prelude

#(%) Source

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

#(^) Source

Operator alias for Math.pow (left-associative / precedence 8)

#fromChar Source

fromChar :: Char -> String

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.

A common use case is to select the first "valid" item, or, if all items are "invalid", the last "invalid" item.

For example:

import Control.Alt ((<|>))
import Data.Maybe (Maybe(..)
import Data.Either (Either(..))

Nothing <|> Just 1 <|> Just 2 == Just 1
Left "err" <|> Right 1 <|> Right 2 == Right 1
Left "err 1" <|> Left "err 2" <|> Left "err 3" == Left "err 3"

Instances

#(<|>) Source

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

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.

lift2 add (Just 1) (Just 2) == Just 3
lift2 add Nothing (Just 2) == Nothing

Re-exports from Control.Parallel

#parTraverse_ Source

parTraverse_ :: forall f m t a b. Parallel f m => Foldable t => (a -> m b) -> t a -> m Unit

Traverse a collection in parallel, discarding any results.

#parTraverse Source

parTraverse :: forall f m t a b. Parallel f m => Traversable t => (a -> m b) -> t a -> m (t b)

Traverse a collection in parallel.

#parSequence_ Source

parSequence_ :: forall a t m f. Parallel f m => Foldable t => t (m a) -> m Unit

#parSequence Source

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

#parOneOfMap Source

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

Race a collection in parallel while mapping to some effect.

#parOneOf Source

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

Race a collection in parallel.

#parApply Source

parApply :: forall f m a b. Parallel f m => m (a -> b) -> m a -> m b

Apply a function to an argument under a type constructor in parallel.

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
  • Generic (Either a b) _
  • Invariant (Either a)
  • 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 f
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

    Either's "do notation" can be understood to work like this:

    x :: forall e a. Either e a
x = --

y :: forall e b. Either e b
y = --

foo :: forall e a. (a -> b -> c) -> Either e c
foo f = do
  x' <- x
  y' <- y
  pure (f x' y')

    ...which is equivalent to...

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

    ...and is the same as writing...

    foo :: forall e a. (a -> b -> c) -> Either e c
foo f = case x of
  Left e ->
    Left e
  Right x -> case y of
    Left e ->
      Left e
    Right y ->
      Right (f x y)
  • Monad (Either e)

    The Monad instance guarantees that there are both Applicative and Bind instances for Either.

  • 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)
  • (Semigroup b) => Semigroup (Either a b)

Re-exports from Data.Either.Nested

#type (\/) Source

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

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]

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

#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 example:

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

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

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

#fold Source

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

Fold a data structure, accumulating values in some Monoid.

Re-exports from Data.FoldableWithIndex

#FoldableWithIndex Source

class (Foldable f) <= FoldableWithIndex i f | f -> i where

A Foldable with an additional index. A FoldableWithIndex instance must be compatible with its Foldable instance

foldr f = foldrWithIndex (const f)
foldl f = foldlWithIndex (const f)
foldMap f = foldMapWithIndex (const f)

Default implementations are provided by the following functions:

  • foldrWithIndexDefault
  • foldlWithIndexDefault
  • foldMapWithIndexDefaultR
  • foldMapWithIndexDefaultL

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

Instances

Re-exports from Data.Function.Uncurried

#Fn9 Source

data Fn9 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

A function of nine arguments

#Fn8 Source

data Fn8 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

A function of eight arguments

#Fn7 Source

data Fn7 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

A function of seven arguments

#Fn6 Source

data Fn6 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

A function of six arguments

#Fn5 Source

data Fn5 :: Type -> Type -> Type -> Type -> Type -> Type -> Type

A function of five arguments

#Fn4 Source

data Fn4 :: Type -> Type -> Type -> Type -> Type -> Type

A function of four arguments

#Fn3 Source

data Fn3 :: Type -> Type -> Type -> Type -> Type

A function of three arguments

#Fn2 Source

data Fn2 :: Type -> Type -> Type -> Type

A function of two arguments

#Fn10 Source

data Fn10 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

A function of ten arguments

#Fn1 Source

type Fn1 a b = a -> b

A function of one argument

#Fn0 Source

data Fn0 :: Type -> Type

A function of zero arguments

#runFn9 Source

runFn9 :: forall a b c d e f g h i j. Fn9 a b c d e f g h i j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j

Apply a function of nine arguments

#runFn8 Source

runFn8 :: forall a b c d e f g h i. Fn8 a b c d e f g h i -> a -> b -> c -> d -> e -> f -> g -> h -> i

Apply a function of eight arguments

#runFn7 Source

runFn7 :: forall a b c d e f g h. Fn7 a b c d e f g h -> a -> b -> c -> d -> e -> f -> g -> h

Apply a function of seven arguments

#runFn6 Source

runFn6 :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g

Apply a function of six arguments

#runFn5 Source

runFn5 :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f

Apply a function of five arguments

#runFn4 Source

runFn4 :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e

Apply a function of four arguments

#runFn3 Source

runFn3 :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d

Apply a function of three arguments

#runFn2 Source

runFn2 :: forall a b c. Fn2 a b c -> a -> b -> c

Apply a function of two arguments

#runFn10 Source

runFn10 :: forall a b c d e f g h i j k. Fn10 a b c d e f g h i j k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k

Apply a function of ten arguments

#runFn1 Source

runFn1 :: forall a b. Fn1 a b -> a -> b

Apply a function of one argument

#runFn0 Source

runFn0 :: forall a. Fn0 a -> a

Apply a function of no arguments

#mkFn9 Source

mkFn9 :: forall a b c d e f g h i j. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> Fn9 a b c d e f g h i j

Create a function of nine arguments from a curried function

#mkFn8 Source

mkFn8 :: forall a b c d e f g h i. (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Fn8 a b c d e f g h i

Create a function of eight arguments from a curried function

#mkFn7 Source

mkFn7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> Fn7 a b c d e f g h

Create a function of seven arguments from a curried function

#mkFn6 Source

mkFn6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g

Create a function of six arguments from a curried function

#mkFn5 Source

mkFn5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f

Create a function of five arguments from a curried function

#mkFn4 Source

mkFn4 :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e

Create a function of four arguments from a curried function

#mkFn3 Source

mkFn3 :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d

Create a function of three arguments from a curried function

#mkFn2 Source

mkFn2 :: forall a b c. (a -> b -> c) -> Fn2 a b c

Create a function of two arguments from a curried function

#mkFn10 Source

mkFn10 :: forall a b c d e f g h i j k. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> Fn10 a b c d e f g h i j k

Create a function of ten arguments from a curried function

#mkFn1 Source

mkFn1 :: forall a b. (a -> b) -> Fn1 a b

Create a function of one argument

#mkFn0 Source

mkFn0 :: forall a. (Unit -> a) -> Fn0 a

Create a function of no arguments

Re-exports from Data.FunctorWithIndex

#FunctorWithIndex Source

class (Functor f) <= FunctorWithIndex i f | f -> i where

A Functor with an additional index. Instances must satisfy a modified form of the Functor laws

mapWithIndex (\_ a -> a) = identity
mapWithIndex f . mapWithIndex g = mapWithIndex (\i -> f i <<< g i)

and be compatible with the Functor instance

map f = mapWithIndex (const f)

Members

Instances

Re-exports from Data.Generic.Rep

#Generic Source

class Generic a rep | a -> rep

The Generic class asserts the existence of a type function from types to their representations using the type constructors defined in this module.

Re-exports from Data.Int

#toNumber Source

toNumber :: Int -> Number

Converts an Int value back into a Number. Any Int is a valid Number so there is no loss of precision with this function.

#round Source

round :: Number -> Int

Convert a Number to an Int, by taking the nearest integer to the argument. Values outside the Int range are clamped, NaN and Infinity values return 0.

#floor Source

floor :: Number -> Int

Convert a Number to an Int, by taking the closest integer equal to or less than the argument. Values outside the Int range are clamped, NaN and Infinity values return 0.

#ceil Source

ceil :: Number -> Int

Convert a Number to an Int, by taking the closest integer equal to or greater than the argument. Values outside the Int range are clamped, NaN and Infinity values return 0.

Re-exports from Data.List

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 function:

    pure 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')))

    Which is equivalent to:

    case x of
  Nothing -> Nothing
  Just x' -> case y of
    Nothing -> Nothing
    Just y' -> Just (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 <<= 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.

  • Generic (Maybe a) _

#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

#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

Re-exports from Data.Show.Generic

#genericShow Source

genericShow :: forall a rep. Generic a rep => GenericShow rep => a -> String

A Generic implementation of the show member from the Show type class.

Re-exports from Data.String

#toUpper Source

toUpper :: String -> String

Returns the argument converted to uppercase.

toUpper "Hello" == "HELLO"

#toLower Source

toLower :: String -> String

Returns the argument converted to lowercase.

toLower "hElLo" == "hello"

Re-exports from Data.String.CodeUnits

#toCharArray Source

toCharArray :: String -> Array Char

Converts the string into an array of characters.

toCharArray "Hello☺\n" == ['H','e','l','l','o','☺','\n']

#fromCharArray Source

fromCharArray :: Array Char -> String

Converts an array of characters into a string.

fromCharArray ['H', 'e', 'l', 'l', 'o'] == "Hello"

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.
import Data.Traversable
import Data.Maybe
import Data.Int (fromNumber)

sequence [Just 1, Just 2, Just 3] == Just [1,2,3]
sequence [Nothing, Just 2, Just 3] == Nothing

traverse fromNumber [1.0, 2.0, 3.0] == Just [1,2,3]
traverse fromNumber [1.5, 2.0, 3.0] == Nothing

traverse logShow [1,2,3]
-- prints:
   1
   2
   3

traverse (\x -> [x, 0]) [1,2,3] == [[1,2,3],[1,2,0],[1,0,3],[1,0,0],[0,2,3],[0,2,0],[0,0,3],[0,0,0]]

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

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

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

Re-exports from Data.TraversableWithIndex

#TraversableWithIndex Source

class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) <= TraversableWithIndex i t | t -> i where

A Traversable with an additional index.
A TraversableWithIndex instance must be compatible with its Traversable instance

traverse f = traverseWithIndex (const f)

with its FoldableWithIndex instance

foldMapWithIndex f = unwrap <<< traverseWithIndex (\i -> Const <<< f i)

and with its FunctorWithIndex instance

mapWithIndex f = unwrap <<< traverseWithIndex (\i -> Identity <<< f i)

A default implementation is provided by traverseWithIndexDefault.

Members

Instances

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.

#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 Data.Unfoldable

#Unfoldable Source

class (Unfoldable1 t) <= Unfoldable t  where

This class identifies (possibly empty) data structures which can be unfolded.

The generating function f in unfoldr f is understood as follows:

  • If f b is Nothing, then unfoldr f b should be empty.
  • If f b is Just (Tuple a b1), then unfoldr f b should consist of a appended to the result of unfoldr f b1.

Note that it is not possible to give Unfoldable instances to types which represent structures which are guaranteed to be non-empty, such as NonEmptyArray: consider what unfoldr (const Nothing) should produce. Structures which are guaranteed to be non-empty can instead be given Unfoldable1 instances.

Members

Instances

Re-exports from Debug

#todo Source

todo :: forall a. a

A placeholder to use when you want your code to compile without finishing something. You will immediately get an error when trying to run any code with a todo, so you won't forget about it and run into errors later.

#debugger Source

debugger :: forall a. a -> a

Inserts a JavaScript debugger statement, then returns its argument.

Re-exports from Effect

#Effect Source

data Effect :: Type -> Type

A native effect. The type parameter denotes the return type of running the effect, that is, an Effect Int is a possibly-effectful computation which eventually produces a value of the type Int when it finishes.

Instances

Re-exports from Effect.Class

#MonadEffect Source

class (Monad m) <= MonadEffect m  where

The MonadEffect class captures those monads which support native effects.

Instances are provided for Effect itself, and the standard monad transformers.

liftEffect can be used in any appropriate monad transformer stack to lift an action of type Effect a into the monad.

Members

Instances

Re-exports from Effect.Class.Console

#logShow Source

logShow :: forall m a. MonadEffect m => Show a => a -> m Unit

#log Source

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

Re-exports from Effect.Exception

#throw Source

throw :: forall a. String -> Effect a

A shortcut allowing you to throw an error in one step. Defined as throwException <<< error.

Re-exports from Effect.Exception.Unsafe

#unsafeThrow Source

unsafeThrow :: forall a. String -> a

Defined as unsafeThrowException <<< error.

Re-exports from Effect.Uncurried

#EffectFn9 Source

data EffectFn9 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn8 Source

data EffectFn8 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn7 Source

data EffectFn7 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn6 Source

data EffectFn6 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn5 Source

data EffectFn5 :: Type -> Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn4 Source

data EffectFn4 :: Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn3 Source

data EffectFn3 :: Type -> Type -> Type -> Type -> Type

Instances

#EffectFn2 Source

data EffectFn2 :: Type -> Type -> Type -> Type

Instances

#EffectFn10 Source

data EffectFn10 :: Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type -> Type

Instances

#EffectFn1 Source

data EffectFn1 :: Type -> Type -> Type

Instances

#runEffectFn9 Source

runEffectFn9 :: forall a b c d e f g h i r. EffectFn9 a b c d e f g h i r -> a -> b -> c -> d -> e -> f -> g -> h -> i -> Effect r

#runEffectFn8 Source

runEffectFn8 :: forall a b c d e f g h r. EffectFn8 a b c d e f g h r -> a -> b -> c -> d -> e -> f -> g -> h -> Effect r

#runEffectFn7 Source

runEffectFn7 :: forall a b c d e f g r. EffectFn7 a b c d e f g r -> a -> b -> c -> d -> e -> f -> g -> Effect r

#runEffectFn6 Source

runEffectFn6 :: forall a b c d e f r. EffectFn6 a b c d e f r -> a -> b -> c -> d -> e -> f -> Effect r

#runEffectFn5 Source

runEffectFn5 :: forall a b c d e r. EffectFn5 a b c d e r -> a -> b -> c -> d -> e -> Effect r

#runEffectFn4 Source

runEffectFn4 :: forall a b c d r. EffectFn4 a b c d r -> a -> b -> c -> d -> Effect r

#runEffectFn3 Source

runEffectFn3 :: forall a b c r. EffectFn3 a b c r -> a -> b -> c -> Effect r

#runEffectFn2 Source

runEffectFn2 :: forall a b r. EffectFn2 a b r -> a -> b -> Effect r

#runEffectFn10 Source

runEffectFn10 :: forall a b c d e f g h i j r. EffectFn10 a b c d e f g h i j r -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> Effect r

#runEffectFn1 Source

runEffectFn1 :: forall a r. EffectFn1 a r -> a -> Effect r

#mkEffectFn9 Source

mkEffectFn9 :: forall a b c d e f g h i r. (a -> b -> c -> d -> e -> f -> g -> h -> i -> Effect r) -> EffectFn9 a b c d e f g h i r

#mkEffectFn8 Source

mkEffectFn8 :: forall a b c d e f g h r. (a -> b -> c -> d -> e -> f -> g -> h -> Effect r) -> EffectFn8 a b c d e f g h r

#mkEffectFn7 Source

mkEffectFn7 :: forall a b c d e f g r. (a -> b -> c -> d -> e -> f -> g -> Effect r) -> EffectFn7 a b c d e f g r

#mkEffectFn6 Source

mkEffectFn6 :: forall a b c d e f r. (a -> b -> c -> d -> e -> f -> Effect r) -> EffectFn6 a b c d e f r

#mkEffectFn5 Source

mkEffectFn5 :: forall a b c d e r. (a -> b -> c -> d -> e -> Effect r) -> EffectFn5 a b c d e r

#mkEffectFn4 Source

mkEffectFn4 :: forall a b c d r. (a -> b -> c -> d -> Effect r) -> EffectFn4 a b c d r

#mkEffectFn3 Source

mkEffectFn3 :: forall a b c r. (a -> b -> c -> Effect r) -> EffectFn3 a b c r

#mkEffectFn2 Source

mkEffectFn2 :: forall a b r. (a -> b -> Effect r) -> EffectFn2 a b r

#mkEffectFn10 Source

mkEffectFn10 :: forall a b c d e f g h i j r. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> Effect r) -> EffectFn10 a b c d e f g h i j r

#mkEffectFn1 Source

mkEffectFn1 :: forall a r. (a -> Effect r) -> EffectFn1 a r

Re-exports from Effect.Unsafe

#unsafePerformEffect Source

unsafePerformEffect :: forall a. Effect a -> a

Run an effectful computation.

Note: use of this function can result in arbitrary side-effects.

Re-exports from MasonPrelude.Functor.Nested

#mmmapFlipped Source

mmmapFlipped :: forall a b f g h. Functor f => Functor g => Functor h => f (g (h a)) -> (a -> b) -> f (g (h b))

#mmmap Source

mmmap :: forall a b f g h. Functor f => Functor g => Functor h => (a -> b) -> f (g (h a)) -> f (g (h b))

#mmapFlipped Source

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

#mmap Source

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

#(<$$>) Source

Operator alias for MasonPrelude.Functor.Nested.mmap (left-associative / precedence 4)

#(<$$$>) Source

Operator alias for MasonPrelude.Functor.Nested.mmap (left-associative / precedence 4)

#(<##>) Source

Operator alias for MasonPrelude.Functor.Nested.mmapFlipped (left-associative / precedence 1)

#(<###>) Source

Operator alias for MasonPrelude.Functor.Nested.mmmapFlipped (left-associative / precedence 1)

Re-exports from MasonPrelude.Parallel

#parLift5 Source

parLift5 :: forall a b c d e f g m. Parallel g m => (a -> b -> c -> d -> e -> f) -> m a -> m b -> m c -> m d -> m e -> m f

#parLift4 Source

parLift4 :: forall a b c d e g m. Parallel g m => (a -> b -> c -> d -> e) -> m a -> m b -> m c -> m d -> m e

#parLift3 Source

parLift3 :: forall a b c d g m. Parallel g m => (a -> b -> c -> d) -> m a -> m b -> m c -> m d

#parLift2 Source

parLift2 :: forall a b c g m. Parallel g m => (a -> b -> c) -> m a -> m b -> m c

Re-exports from PointFree

#composeThirdFlipped Source

composeThirdFlipped :: forall a b x y z. (z -> b) -> (x -> y -> b -> a) -> x -> y -> z -> a

#composeThird Source

composeThird :: forall a b x y z. (x -> y -> b -> a) -> (z -> b) -> x -> y -> z -> a

\f g x y z -> f x y (g z)

#composeSecondFlipped Source

composeSecondFlipped :: forall a b x y. (y -> b) -> (x -> b -> a) -> x -> y -> a

#composeSecond Source

composeSecond :: forall a b x y. (x -> b -> a) -> (y -> b) -> x -> y -> a

\f g x y -> f x (g y)

#composeFourthFlipped Source

composeFourthFlipped :: forall a b w x y z. (z -> b) -> (w -> x -> y -> b -> a) -> w -> x -> y -> z -> a

#composeFourth Source

composeFourth :: forall a b w x y z. (w -> x -> y -> b -> a) -> (z -> b) -> w -> x -> y -> z -> a

\f g w x y z -> f w x y (g z)

#compose4Flipped Source

compose4Flipped :: forall a b w x y z. (w -> x -> y -> z -> a) -> (a -> b) -> w -> x -> y -> z -> b

#compose4 Source

compose4 :: forall a b w x y z. (a -> b) -> (w -> x -> y -> z -> a) -> w -> x -> y -> z -> b

\f g w x y z -> f (g w x y z)

#compose3SecondFlipped Source

compose3SecondFlipped :: forall a b w x y z. (x -> y -> z -> b) -> (w -> b -> a) -> w -> x -> y -> z -> a

#compose3Second Source

compose3Second :: forall a b w x y z. (w -> b -> a) -> (x -> y -> z -> b) -> w -> x -> y -> z -> a

\f g w x y z -> f w (g x y z)

#compose3Flipped Source

compose3Flipped :: forall a b x y z. (x -> y -> z -> a) -> (a -> b) -> x -> y -> z -> b

#compose3 Source

compose3 :: forall a b x y z. (a -> b) -> (x -> y -> z -> a) -> x -> y -> z -> b

\f g x y z -> f (g x y z)

#compose2ThirdFlipped Source

compose2ThirdFlipped :: forall a b w x y z. (y -> z -> b) -> (w -> x -> b -> a) -> w -> x -> y -> z -> a

#compose2Third Source

compose2Third :: forall a b w x y z. (w -> x -> b -> a) -> (y -> z -> b) -> w -> x -> y -> z -> a

\f g w x y z -> f w x (g y z)

#compose2SecondFlipped Source

compose2SecondFlipped :: forall a b x y z. (y -> z -> b) -> (x -> b -> a) -> x -> y -> z -> a

#compose2Second Source

compose2Second :: forall a b x y z. (x -> b -> a) -> (y -> z -> b) -> x -> y -> z -> a

\f g x y z -> f x (g y z)

#compose2Flipped Source

compose2Flipped :: forall a b x y. (x -> y -> a) -> (a -> b) -> x -> y -> b

#compose2 Source

compose2 :: forall a b x y. (a -> b) -> (x -> y -> a) -> x -> y -> b

\f g x y -> f (g x y)

#applyThirdFlipped Source

applyThirdFlipped :: forall x y z a. x -> (y -> z -> x -> a) -> y -> z -> a

#applyThird Source

applyThird :: forall x y z a. (y -> z -> x -> a) -> x -> y -> z -> a

\f x y z -> f y z x

#applySecondFlipped Source

applySecondFlipped :: forall x y a. x -> (y -> x -> a) -> y -> a

#applySecond Source

applySecond :: forall x y a. (y -> x -> a) -> x -> y -> a

\f x y -> f y x

(flip)

#applyFourthFlipped Source

applyFourthFlipped :: forall w x y z a. w -> (x -> y -> z -> w -> a) -> x -> y -> z -> a

#applyFourth Source

applyFourth :: forall w x y z a. (x -> y -> z -> w -> a) -> w -> x -> y -> z -> a

\f w x y z -> f x y z w

#(~~~.>) Source

Operator alias for PointFree.composeFourthFlipped (right-associative / precedence 9)

#(~~~$) Source

Operator alias for PointFree.applyFourth (left-associative / precedence 8)

#(~~~#) Source

Operator alias for PointFree.applyFourthFlipped (right-associative / precedence 8)

#(~~.>) Source

Operator alias for PointFree.composeThirdFlipped (right-associative / precedence 9)

#(~~..>) Source

Operator alias for PointFree.compose2ThirdFlipped (right-associative / precedence 9)

#(~~$) Source

Operator alias for PointFree.applyThird (left-associative / precedence 8)

#(~~#) Source

Operator alias for PointFree.applyThirdFlipped (right-associative / precedence 8)

#(~.>) Source

Operator alias for PointFree.composeSecondFlipped (right-associative / precedence 9)

#(~..>) Source

Operator alias for PointFree.compose2SecondFlipped (right-associative / precedence 9)

#(~...>) Source

Operator alias for PointFree.compose3SecondFlipped (left-associative / precedence 9)

#(~$) Source

Operator alias for PointFree.applySecond (left-associative / precedence 8)

#(~#) Source

Operator alias for PointFree.applySecondFlipped (right-associative / precedence 8)

#(<~~~.) Source

Operator alias for PointFree.composeFourth (left-associative / precedence 9)

#(<~~..) Source

Operator alias for PointFree.compose2Third (left-associative / precedence 9)

#(<~~.) Source

Operator alias for PointFree.composeThird (left-associative / precedence 9)

#(<~...) Source

Operator alias for PointFree.compose3Second (left-associative / precedence 9)

#(<~..) Source

Operator alias for PointFree.compose2Second (left-associative / precedence 9)

#(<~.) Source

Operator alias for PointFree.composeSecond (left-associative / precedence 9)

#(<....) Source

Operator alias for PointFree.compose4 (left-associative / precedence 9)

#(<...) Source

Operator alias for PointFree.compose3 (left-associative / precedence 9)

#(<..) Source

Operator alias for PointFree.compose2 (left-associative / precedence 9)

#(<.) Source

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

\f g x -> f (g x)

#(.>) Source

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

#(..>) Source

Operator alias for PointFree.compose2Flipped (right-associative / precedence 9)

#(...>) Source

Operator alias for PointFree.compose3Flipped (right-associative / precedence 9)

#(....>) Source

Operator alias for PointFree.compose4Flipped (right-associative / precedence 9)

Re-exports from Prelude

#Void Source

newtype Void

An uninhabited data type. In other words, one can never create a runtime value of type Void becaue no such value exists.

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.

This should not be confused with the keyword void that commonly appears in C-family languages, such as Java:

public class Foo {
  void doSomething() { System.out.println("hello world!"); }
}

In PureScript, one often uses Unit to achieve similar effects as the void of C-family languages above.

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.

When returning a value of type Unit from an FFI function, it is recommended to use undefined, or not return a value at all.

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 identity) <*> 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.

Put differently...

foo =
  functionTakingNArguments <$> computationProducingArg1
                           <*> computationProducingArg2
                           <*> ...
                           <*> computationProducingArgN

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 laws in addition to the Apply laws:

  • Associativity: (x >>= f) >>= g = x >>= (\k -> f k >>= g)
  • Apply Superclass: apply f x = f >>= \f’ -> map f’ x

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

  • Bind (Function r)
  • Bind Array

    The bind/>>= function for Array works by applying a function to each element in the array, and flattening the results into a single, new array.

    Array's bind/>>= works like a nested for loop. Each bind adds another level of nesting in the loop. For example:

    foo :: Array String
foo =
  ["a", "b"] >>= \eachElementInArray1 ->
    ["c", "d"] >>= \eachElementInArray2
      pure (eachElementInArray1 <> eachElementInArray2)

-- In other words...
foo
-- ... is the same as...
[ ("a" <> "c"), ("a" <> "d"), ("b" <> "c"), ("b" <> "d") ]
-- which simplifies to...
[ "ac", "ad", "bc", "bd" ]
  • Bind Proxy

#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

Members

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

#DivisionRing Source

class (Ring a) <= DivisionRing a  where

The DivisionRing class is for non-zero rings in which every non-zero element has a multiplicative inverse. Division rings are sometimes also called skew fields.

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

  • Non-zero ring: one /= zero
  • Non-zero multiplicative inverse: recip a * a = a * recip a = one for all non-zero a

The result of recip zero is left undefined; individual instances may choose how to handle this case.

If a type has both DivisionRing and CommutativeRing instances, then it is a field and should have a Field instance.

Members

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 EuclideanRing Int instance is one of the most commonly used EuclideanRing instances and deserves a little more discussion. In particular, there are a few different sensible law-abiding implementations to choose from, with slightly different behaviour in the presence of negative dividends or divisors. The most common definitions are "truncating" division, where the result of a / b is rounded towards 0, and "Knuthian" or "flooring" division, where the result of a / b is rounded towards negative infinity. A slightly less common, but arguably more useful, option is "Euclidean" division, which is defined so as to ensure that a `mod` b is always nonnegative. With Euclidean division, a / b rounds towards negative infinity if the divisor is positive, and towards positive infinity if the divisor is negative. Note that all three definitions are identical if we restrict our attention to nonnegative dividends and divisors.

In versions 1.x, 2.x, and 3.x of the Prelude, the EuclideanRing Int instance used truncating division. As of 4.x, the EuclideanRing Int instance uses Euclidean division. Additional functions quot and rem are supplied if truncating division is desired.

Members

Instances

#Field Source

class (EuclideanRing a, DivisionRing a) <= Field a

The Field class is for types that are (commutative) fields.

Mathematically, a field is a ring which is commutative and in which every nonzero element has a multiplicative inverse; these conditions correspond to the CommutativeRing and DivisionRing classes in PureScript respectively. However, the Field class has EuclideanRing and DivisionRing as superclasses, which seems like a stronger requirement (since CommutativeRing is a superclass of EuclideanRing). In fact, it is not stronger, since any type which has law-abiding CommutativeRing and DivisionRing instances permits exactly one law-abiding EuclideanRing instance. We use a EuclideanRing superclass here in order to ensure that a Field constraint on a function permits you to use div on that type, since div is a member of EuclideanRing.

This class has no laws or members of its own; it exists as a convenience, so a single constraint can be used when field-like behaviour is expected.

This module also defines a single Field instance for any type which has both EuclideanRing and DivisionRing instances. Any other instance would overlap with this instance, so no other Field instances should be defined in libraries. Instead, simply define EuclideanRing and DivisionRing instances, and this will permit your type to be used with a Field constraint.

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 identity = identity
  • 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

#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 <>:

  • Left unit: (mempty <> x) = x
  • Right unit: (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.

Newtypes for Monoid

Some types (e.g. Int, Boolean) can implement multiple law-abiding instances for Monoid. Let's use Int as an example

  1. <> could be + and mempty could be 0
  2. <> could be * and mempty could be 1.

To clarify these ambiguous situations, one should use the newtypes defined in Data.Monoid.<NewtypeName> modules.

In the above ambiguous situation, we could use Additive for the first situation or Multiplicative for the second one.

Members

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 laws in addition to the Semiring laws:

  • Additive inverse: a - a = zero
  • Compatibility of sub and negate: a - b = a + (zero - b)

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. Another example is List a, with (<>) defined as list concatenation.

Newtypes for Semigroup

There are two other ways to implement an instance for this type class regardless of which type is used. These instances can be used by wrapping the values in one of the two newtypes below:

  1. First - Use the first argument every time: append first _ = first.
  2. Last - Use the last argument every time: append _ last = last.

Members

Instances

#Semigroupoid Source

class Semigroupoid a  where

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 an 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 an 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 -> Array 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

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

const 1 = \_ -> 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

Eliminator for the Void type. Useful for stating that some code branch is impossible because you've "acquired" a value of type Void (which you can't).

rightOnly :: forall t . Either Void t -> t
rightOnly (Left v) = absurd v
rightOnly (Right t) = t

#(||) 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

#Proxy Source

data Proxy a

Constructors

Re-exports from Unsafe.Coerce

#unsafeCoerce 

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.

Because this function is extraordinarily flexible, type inference can greatly suffer. It is highly recommended to define specializations of this function rather than using it as-is. For example:

fromBoolean :: Boolean -> Json
fromBoolean = unsafeCoerce

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

After the v0.14.0 PureScript release, some of what was accomplished via unsafeCoerce can now be accomplished via coerce from purescript-safe-coerce. See that library's documentation for more context.

Modules
MasonPrelude
MasonPrelude.Functor.Nested
MasonPrelude.Parallel