MasonPrelude

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

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

fromChar :: Char -> String

class Alt :: (Type -> Type) -> Constraintclass (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

• Alt Array

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

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

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

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

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

data Either a b

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

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

Constructors

• Left a
• Right b

Instances

• Functor (Either a)

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

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

  Left values are untouched:

  f <$> Left y == Left y
  

• 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)

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

class Foldable :: (Type -> Type) -> Constraintclass 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

• Foldable Array
• Foldable Maybe
• Foldable First
• Foldable Last
• Foldable Additive
• Foldable Dual
• Foldable Disj
• Foldable Conj
• Foldable Multiplicative
• Foldable (Either a)
• Foldable (Tuple a)
• Foldable Identity
• Foldable (Const a)
• (Foldable f, Foldable g) => Foldable (Product f g)
• (Foldable f, Foldable g) => Foldable (Coproduct f g)
• (Foldable f, Foldable g) => Foldable (Compose f g)
• (Foldable f) => Foldable (App f)

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_ :: 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 :: 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 :: forall f m. Foldable f => Monoid m => f m -> m

Fold a data structure, accumulating values in some Monoid.

class FoldableWithIndex :: Type -> (Type -> Type) -> Constraintclass (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

• foldrWithIndex :: forall a b. (i -> a -> b -> b) -> b -> f a -> b
• foldlWithIndex :: forall a b. (i -> b -> a -> b) -> b -> f a -> b
• foldMapWithIndex :: forall a m. Monoid m => (i -> a -> m) -> f a -> m

Instances

• FoldableWithIndex Int Array
• FoldableWithIndex Unit Maybe
• FoldableWithIndex Unit First
• FoldableWithIndex Unit Last
• FoldableWithIndex Unit Additive
• FoldableWithIndex Unit Dual
• FoldableWithIndex Unit Disj
• FoldableWithIndex Unit Conj
• FoldableWithIndex Unit Multiplicative
• FoldableWithIndex Unit (Either a)
• FoldableWithIndex Unit (Tuple a)
• FoldableWithIndex Unit Identity
• FoldableWithIndex Void (Const a)
• (FoldableWithIndex a f, FoldableWithIndex b g) => FoldableWithIndex (Either a b) (Product f g)
• (FoldableWithIndex a f, FoldableWithIndex b g) => FoldableWithIndex (Either a b) (Coproduct f g)
• (FoldableWithIndex a f, FoldableWithIndex b g) => FoldableWithIndex (Tuple a b) (Compose f g)
• (FoldableWithIndex a f) => FoldableWithIndex a (App f)

data Fn9 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9

A function of nine arguments

data Fn8 t0 t1 t2 t3 t4 t5 t6 t7 t8

A function of eight arguments

data Fn7 t0 t1 t2 t3 t4 t5 t6 t7

A function of seven arguments

data Fn6 t0 t1 t2 t3 t4 t5 t6

A function of six arguments

data Fn5 t0 t1 t2 t3 t4 t5

A function of five arguments

data Fn4 t0 t1 t2 t3 t4

A function of four arguments

data Fn3 t0 t1 t2 t3

A function of three arguments

data Fn2 t0 t1 t2

A function of two arguments

data Fn10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10

A function of ten arguments

type Fn1 a b = a -> b

A function of one argument

data Fn0 t0

A function of zero arguments

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

Apply a function of four arguments

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

Apply a function of three arguments

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

Apply a function of two arguments

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

Apply a function of one argument

runFn0 :: forall a. Fn0 a -> a

Apply a function of no arguments

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

Create a function of two arguments from a curried function

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 :: forall a b. (a -> b) -> Fn1 a b

Create a function of one argument

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

Create a function of no arguments

class FunctorWithIndex :: Type -> (Type -> Type) -> Constraintclass (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

• mapWithIndex :: forall a b. (i -> a -> b) -> f a -> f b

Instances

• FunctorWithIndex Int Array
• FunctorWithIndex Unit Maybe
• FunctorWithIndex Unit First
• FunctorWithIndex Unit Last
• FunctorWithIndex Unit Additive
• FunctorWithIndex Unit Dual
• FunctorWithIndex Unit Conj
• FunctorWithIndex Unit Disj
• FunctorWithIndex Unit Multiplicative
• FunctorWithIndex Unit (Either a)
• FunctorWithIndex Unit (Tuple a)
• FunctorWithIndex Unit Identity
• FunctorWithIndex Void (Const a)
• (FunctorWithIndex a f, FunctorWithIndex b g) => FunctorWithIndex (Either a b) (Product f g)
• (FunctorWithIndex a f, FunctorWithIndex b g) => FunctorWithIndex (Either a b) (Coproduct f g)
• (FunctorWithIndex a f, FunctorWithIndex b g) => FunctorWithIndex (Tuple a b) (Compose f g)
• (FunctorWithIndex a f) => FunctorWithIndex a (App f)

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.

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

data List a

Constructors

• Nil
• Cons a (List a)

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
• FunctorWithIndex Int List
• Foldable List
• FoldableWithIndex Int List
• Unfoldable1 List
• Unfoldable List
• Traversable List
• TraversableWithIndex Int List
• Apply List
• Applicative List
• Bind List
• Monad List
• Alt List
• Plus List
• Alternative List
• MonadPlus List
• Extend List

data Maybe a

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

Constructors

• Nothing
• Just a

Instances

• Functor Maybe

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

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

  Nothing values are left untouched:

  f <$> Nothing == Nothing
  

• Apply Maybe

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

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

  Nothing values are left untouched:

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

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

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

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

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

• Applicative Maybe

  The Applicative instance enables lifting of values into Maybe with the pure 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')
  

• 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)
• (Semiring a) => Semiring (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 :: 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 :: 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

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

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

toUpper :: String -> String

Returns the argument converted to uppercase.

toUpper "Hello" == "HELLO"

toLower :: String -> String

Returns the argument converted to lowercase.

toLower "hElLo" == "hello"

toCharArray :: String -> Array Char

Converts the string into an array of characters.

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

fromCharArray :: Array Char -> String

Converts an array of characters into a string.

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

class Traversable :: (Type -> Type) -> Constraintclass (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

• traverse :: forall a b m. Applicative m => (a -> m b) -> t a -> m (t b)
• sequence :: forall a m. Applicative m => t (m a) -> m (t a)

Instances

• Traversable Array
• Traversable Maybe
• Traversable First
• Traversable Last
• Traversable Additive
• Traversable Dual
• Traversable Conj
• Traversable Disj
• Traversable Multiplicative
• Traversable (Either a)
• Traversable (Tuple a)
• Traversable Identity
• Traversable (Const a)
• (Traversable f, Traversable g) => Traversable (Product f g)
• (Traversable f, Traversable g) => Traversable (Coproduct f g)
• (Traversable f, Traversable g) => Traversable (Compose f g)
• (Traversable f) => Traversable (App f)

class TraversableWithIndex :: Type -> (Type -> Type) -> Constraintclass (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

• traverseWithIndex :: forall a b m. Applicative m => (i -> a -> m b) -> t a -> m (t b)

Instances

• TraversableWithIndex Int Array
• TraversableWithIndex Unit Maybe
• TraversableWithIndex Unit First
• TraversableWithIndex Unit Last
• TraversableWithIndex Unit Additive
• TraversableWithIndex Unit Dual
• TraversableWithIndex Unit Conj
• TraversableWithIndex Unit Disj
• TraversableWithIndex Unit Multiplicative
• TraversableWithIndex Unit (Either a)
• TraversableWithIndex Unit (Tuple a)
• TraversableWithIndex Unit Identity
• TraversableWithIndex Void (Const a)
• (TraversableWithIndex a f, TraversableWithIndex b g) => TraversableWithIndex (Either a b) (Product f g)
• (TraversableWithIndex a f, TraversableWithIndex b g) => TraversableWithIndex (Either a b) (Coproduct f g)
• (TraversableWithIndex a f, TraversableWithIndex b g) => TraversableWithIndex (Tuple a b) (Compose f g)
• (TraversableWithIndex a f) => TraversableWithIndex a (App f)

data Tuple a b

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

Constructors

• Tuple a b

Instances

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

  Allows Tuples to be rendered as a string with show whenever there are Show instances for both component types.

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

  Allows Tuples to be checked for equality with == and /= whenever there are Eq instances for both component types.

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

  Allows Tuples to be compared with compare, >, >=, < and <= whenever there are Ord instances for both component types. To obtain the result, the fsts are compared, and if they are EQual, the snds are compared.

• (Ord a) => Ord1 (Tuple a)
• (Bounded a, Bounded b) => Bounded (Tuple a b)
• Semigroupoid Tuple
• (Semigroup a, Semigroup b) => Semigroup (Tuple a b)

  The Semigroup instance enables use of the associative operator <> on Tuples whenever there are Semigroup instances for the component types. The <> operator is applied pairwise, so:

  (Tuple a1 b1) <> (Tuple a2 b2) = Tuple (a1 <> a2) (b1 <> b2)
  

• (Monoid a, Monoid b) => Monoid (Tuple a b)
• (Semiring a, Semiring b) => Semiring (Tuple a b)
• (Ring a, Ring b) => Ring (Tuple a b)
• (CommutativeRing a, CommutativeRing b) => CommutativeRing (Tuple a b)
• (HeytingAlgebra a, HeytingAlgebra b) => HeytingAlgebra (Tuple a b)
• (BooleanAlgebra a, BooleanAlgebra b) => BooleanAlgebra (Tuple a b)
• Functor (Tuple a)

  The Functor instance allows functions to transform the contents of a Tuple with the <$> operator, applying the function to the second component, so:

  f <$> (Tuple x y) = Tuple x (f y)
  

• Generic (Tuple a b) _
• Invariant (Tuple a)
• (Semigroup a) => Apply (Tuple a)

  The Apply instance allows functions to transform the contents of a Tuple with the <*> operator whenever there is a Semigroup instance for the fst component, so:

  (Tuple a1 f) <*> (Tuple a2 x) == Tuple (a1 <> a2) (f x)
  

• (Monoid a) => Applicative (Tuple a)
• (Semigroup a) => Bind (Tuple a)
• (Monoid a) => Monad (Tuple a)
• Extend (Tuple a)
• Comonad (Tuple a)
• (Lazy a, Lazy b) => Lazy (Tuple a b)

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

Returns the second component of a tuple.

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

Returns the first component of a tuple.

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.

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

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

class Unfoldable :: (Type -> Type) -> Constraintclass (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

• unfoldr :: forall a b. (b -> Maybe (Tuple a b)) -> b -> t a

Instances

• Unfoldable Array
• Unfoldable Maybe

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

Inserts a JavaScript debugger statement, then returns its argument.

data Effect t0

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

• Functor Effect
• Apply Effect
• Applicative Effect
• Bind Effect
• Monad Effect
• (Semigroup a) => Semigroup (Effect a)

  The Semigroup instance for effects allows you to run two effects, one after the other, and then combine their results using the result type's Semigroup instance.

• (Monoid a) => Monoid (Effect a)

  If you have a Monoid a instance, then mempty :: Effect a is defined as pure mempty.

class MonadEffect :: (Type -> Type) -> Constraintclass (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

• liftEffect :: forall a. Effect a -> m a

Instances

• MonadEffect Effect

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

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

throw :: forall a. String -> Effect a

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

unsafeThrow :: forall a. String -> a

Defined as unsafeThrowException <<< error.

data EffectFn9 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9

Instances

• (Semigroup r) => Semigroup (EffectFn9 a b c d e f g h i r)
• (Monoid r) => Monoid (EffectFn9 a b c d e f g h i r)

data EffectFn8 t0 t1 t2 t3 t4 t5 t6 t7 t8

Instances

• (Semigroup r) => Semigroup (EffectFn8 a b c d e f g h r)
• (Monoid r) => Monoid (EffectFn8 a b c d e f g h r)

data EffectFn7 t0 t1 t2 t3 t4 t5 t6 t7

Instances

• (Semigroup r) => Semigroup (EffectFn7 a b c d e f g r)
• (Monoid r) => Monoid (EffectFn7 a b c d e f g r)

data EffectFn6 t0 t1 t2 t3 t4 t5 t6

Instances

• (Semigroup r) => Semigroup (EffectFn6 a b c d e f r)
• (Monoid r) => Monoid (EffectFn6 a b c d e f r)

data EffectFn5 t0 t1 t2 t3 t4 t5

Instances

• (Semigroup r) => Semigroup (EffectFn5 a b c d e r)
• (Monoid r) => Monoid (EffectFn5 a b c d e r)

data EffectFn4 t0 t1 t2 t3 t4

Instances

• (Semigroup r) => Semigroup (EffectFn4 a b c d r)
• (Monoid r) => Monoid (EffectFn4 a b c d r)

data EffectFn3 t0 t1 t2 t3

Instances

• (Semigroup r) => Semigroup (EffectFn3 a b c r)
• (Monoid r) => Monoid (EffectFn3 a b c r)

data EffectFn2 t0 t1 t2

Instances

• (Semigroup r) => Semigroup (EffectFn2 a b r)
• (Monoid r) => Monoid (EffectFn2 a b r)

data EffectFn10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10

Instances

• (Semigroup r) => Semigroup (EffectFn10 a b c d e f g h i j r)
• (Monoid r) => Monoid (EffectFn10 a b c d e f g h i j r)

data EffectFn1 t0 t1

Instances

• (Semigroup r) => Semigroup (EffectFn1 a r)
• (Monoid r) => Monoid (EffectFn1 a r)

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 :: 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 :: 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 :: 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 :: forall a b c d e r. EffectFn5 a b c d e r -> a -> b -> c -> d -> e -> Effect r

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

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

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

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 :: forall a r. EffectFn1 a r -> a -> Effect r

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 :: 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 :: 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 :: 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 :: forall a b c d e r. (a -> b -> c -> d -> e -> Effect r) -> EffectFn5 a b c d e r

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

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

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

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 :: forall a r. (a -> Effect r) -> EffectFn1 a r

unsafePerformEffect :: forall a. Effect a -> a

Run an effectful computation.

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

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

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

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

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

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

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

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

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

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 :: 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 :: forall a b c d g m. Parallel g m => (a -> b -> c -> d) -> m a -> m b -> m c -> m d

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

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

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 :: forall a b x y. (y -> b) -> (x -> b -> a) -> x -> y -> a

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

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

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

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 :: forall a b w x y z. (w -> x -> y -> z -> a) -> (a -> b) -> w -> x -> y -> z -> b

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 :: forall a b w x y z. (x -> y -> z -> b) -> (w -> b -> a) -> w -> x -> y -> z -> a

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 :: forall a b x y z. (x -> y -> z -> a) -> (a -> b) -> x -> y -> z -> b

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 :: forall a b w x y z. (y -> z -> b) -> (w -> x -> b -> a) -> w -> x -> y -> z -> a

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 :: forall a b x y z. (y -> z -> b) -> (x -> b -> a) -> x -> y -> z -> a

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 :: forall a b x y. (x -> y -> a) -> (a -> b) -> x -> y -> b

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

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

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

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

\f x y z -> f y z x

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

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

\f x y -> f y x

(flip)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

\f g x -> f (g x)

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

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

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

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

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

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

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

newtype Void

An uninhabited data type. In other words, one can never create a runtime value of type Void because 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

• Show Void

data Unit

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

• Show Unit

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

• LT
• GT
• EQ

Instances

• Eq Ordering
• Semigroup Ordering
• Show Ordering

class Applicative :: (Type -> Type) -> Constraintclass (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

• Applicative (Function r)
• Applicative Array
• Applicative Proxy

class Apply :: (Type -> Type) -> Constraintclass (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

• Apply (Function r)
• Apply Array
• Apply Proxy

class Bind :: (Type -> Type) -> Constraintclass (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

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

• BooleanAlgebra Boolean
• BooleanAlgebra Unit
• (BooleanAlgebra b) => BooleanAlgebra (a -> b)
• (RowToList row list, BooleanAlgebraRecord list row row) => BooleanAlgebra (Record row)
• BooleanAlgebra (Proxy a)

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

• top :: a
• bottom :: a

Instances

• Bounded Boolean
• Bounded Int

  The Bounded Int instance has top :: Int equal to 2^31 - 1, and bottom :: Int equal to -2^31, since these are the largest and smallest integers representable by twos-complement 32-bit integers, respectively.

• Bounded Char

  Characters fall within the Unicode range.

• Bounded Ordering
• Bounded Unit
• Bounded Number
• Bounded (Proxy a)
• (RowToList row list, BoundedRecord list row row) => Bounded (Record row)

class Category :: forall k. (k -> k -> Type) -> Constraintclass (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: identity <<< p = p <<< identity = p

Members

• identity :: forall t. a t t

Instances

• Category Function

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

• CommutativeRing Int
• CommutativeRing Number
• CommutativeRing Unit
• (CommutativeRing b) => CommutativeRing (a -> b)
• (RowToList row list, CommutativeRingRecord list row row) => CommutativeRing (Record row)
• CommutativeRing (Proxy a)