MasonPrelude

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

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

fromChar :: Char -> String

class (Functor f) <= Alt f 

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

Alt instances are required to satisfy the following laws:

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

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

Instances

• Alt Array

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

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

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

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

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

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

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

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

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

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

Traverse a collection in parallel, discarding any results.

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

Traverse a collection in parallel.

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

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

parOneOfMap :: forall f m t b a. 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 f m t a. Parallel f m => Alternative f => Foldable t => Functor t => t (m a) -> m a

Race a collection in parallel.

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

Apply a function to an arguement 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
  

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

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

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

  Left values are left untouched:

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

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

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

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

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

• Applicative (Either e)

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

  pure x :: Either _ _ == Right x
  

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

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

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

• Alt (Either e)

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

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

• Bind (Either e)

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

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

• Monad (Either e)

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

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

  Which is equivalent to:

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

• Extend (Either e)

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

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

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

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

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

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

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

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

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

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

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

class Foldable f  where

Foldable represents data structures which can be folded.

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

Default implementations are provided by the following functions:

• foldrDefault
• foldlDefault
• foldMapDefaultR
• foldMapDefaultL

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

Members

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

Instances

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

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

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

For example:

traverse_ print [1, 2, 3]

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

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

For example:

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

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

Fold a data structure, accumulating values in some Monoid, combining adjacent elements using the specified separator.

For 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 m f. Foldable f => Monoid m => f m -> m

Fold a data structure, accumulating values in some Monoid.

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

• foldrWithIndex :: forall b a. (i -> a -> b -> b) -> b -> f a -> b
• foldlWithIndex :: forall b a. (i -> b -> a -> b) -> b -> f a -> b
• foldMapWithIndex :: forall m a. 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

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

A function of nine arguments

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

A function of eight arguments

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

A function of seven arguments

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

A function of six arguments

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

A function of five arguments

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

A function of four arguments

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

A function of three arguments

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

A function of two arguments

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

A function of ten arguments

type Fn1 a b = a -> b

A function of one argument

data Fn0 :: Type -> Type

A function of zero arguments

runFn9 :: forall j i h g f e d c b a. 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 i h g f e d c b a. 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 h g f e d c b a. 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 g f e d c b a. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g

Apply a function of six arguments

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

Apply a function of five arguments

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

Apply a function of four arguments

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

Apply a function of three arguments

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

Apply a function of two arguments

runFn10 :: forall k j i h g f e d c b a. 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 b a. 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 j i h g f e d c b a. (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 i h g f e d c b a. (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 h g f e d c b a. (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 g f e d c b a. (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 f e d c b a. (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 e d c b a. (a -> b -> c -> d -> e) -> Fn4 a b c d e

Create a function of four arguments from a curried function

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

Create a function of three arguments from a curried function

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

Create a function of two arguments from a curried function

mkFn10 :: forall k j i h g f e d c b a. (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 b a. (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 (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 b a. (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

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.

Instances

• Generic (Maybe a) (Sum (Constructor "Nothing" NoArguments) (Constructor "Just" (Argument a)))

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

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

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

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

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

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

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

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

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 (Functor t, Foldable t) <= Traversable t  where

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

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

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

• traverse f xs = sequence (f <$> xs)
• sequence = traverse 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 m b a. Applicative m => (a -> m b) -> t a -> m (t b)
• sequence :: forall m a. 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

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

• traverseWithIndex :: forall m b a. 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

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)
  

• FunctorWithIndex Unit (Tuple a)
• Invariant (Tuple a)
• Bifunctor Tuple
• (Semigroup a) => Apply (Tuple a)

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

• Biapply Tuple
• (Monoid a) => Applicative (Tuple a)
• Biapplicative Tuple
• (Semigroup a) => Bind (Tuple a)
• (Monoid a) => Monad (Tuple a)
• Extend (Tuple a)
• Comonad (Tuple a)
• (Lazy a, Lazy b) => Lazy (Tuple a b)
• Foldable (Tuple a)
• Foldable1 (Tuple a)
• FoldableWithIndex Unit (Tuple a)
• Bifoldable Tuple
• Traversable (Tuple a)
• Traversable1 (Tuple a)
• TraversableWithIndex Unit (Tuple a)
• Bitraversable Tuple
• (TypeEquals a Unit) => Distributive (Tuple a)

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

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

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

Returns the second component of a tuple.

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

Returns the first component of a tuple.

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

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

• 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 (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 a m. 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.

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

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

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

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

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

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

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

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

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

data EffectFn1 :: Type -> Type -> Type

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

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

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

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

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

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

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

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

runEffectFn10 :: forall r j i h g f e d c b a. 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 r a. EffectFn1 a r -> a -> Effect r

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

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

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

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

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

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

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

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

mkEffectFn10 :: forall r j i h g f e d c b a. (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 r a. (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 h g f b a. Functor f => Functor g => Functor h => f (g (h a)) -> (a -> b) -> f (g (h b))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

\f x y z -> f y z x

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

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

\f x y -> f y x

(flip)

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

applyFourth :: forall a z y x w. (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.applyFourthFlipped (right-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.applyThirdFlipped (right-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.applySecondFlipped (right-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)

newtype Void

An uninhabited data type.

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

Instances

• Show Void

data Unit :: Type

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

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

Instances

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

class (Functor f) <= Apply f  where

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

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

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

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

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

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

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

Members

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

Instances

• Apply (Function r)
• Apply Array

class (Apply m) <= Bind m  where

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

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

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

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

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

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

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

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

Members

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

Instances

• Bind (Function r)
• Bind Array

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)

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

class (Semigroupoid a) <= Category a  where

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

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

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

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

Instances

• Discard Unit

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

• recip :: a -> a

Instances

• DivisionRing Number

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

• eq :: a -> a -> Boolean

Instances

• Eq Boolean
• Eq Int
• Eq Number
• Eq Char
• Eq String
• Eq Unit
• Eq Void
• (Eq a) => Eq (Array a)
• (RowToList row list, EqRecord list row) => Eq (Record row)

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

• degree :: a -> Int
• div :: a -> a -> a
• mod :: a -> a -> a

Instances

• EuclideanRing Int
• EuclideanRing Number

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

• (EuclideanRing a, DivisionRing a) => Field a

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

Instances

• Functor (Function r)
• Functor Array

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