Paxl

type PAXL reqs = GENPAXL (Fetch reqs)

type Paxl reqs = GenPaxl (Fetch reqs)

type PaxlEffects reqs eff = GenPaxlEffects (Fetch reqs) eff

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

type ApplyRowType (f :: Row Type -> Row Type) r = f r

type ApplyRowEffect (f :: Row Effect -> Row Effect) r = f r

class (Apply f) <= Applicative f  where

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

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

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

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

Members

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

Instances

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

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
• Bounded Char

  Characters fall within the Unicode range.

• Bounded Ordering
• Bounded Unit

class (Semigroupoid a) <= Category a  where

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

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

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

Members

• id :: forall t. a t t

Instances

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

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)

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.

Members

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

Instances

• EuclideanRing Int
• EuclideanRing Number

class (EuclideanRing a) <= Field a 

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

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

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

If a type has a Field instance, it should also have a DivisionRing instance. In a future release, DivisionRing may become a superclass of Field.

Instances

• Field Number

class Functor f  where

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

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

Instances must satisfy the following laws:

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

Members

• map :: forall 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

Members

• conj :: a -> a -> a
• disj :: a -> a -> a
• not :: a -> a

Instances

• HeytingAlgebra Boolean
• HeytingAlgebra Unit
• (HeytingAlgebra b) => HeytingAlgebra (a -> b)

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

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

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

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

Instances

• Monad (Function r)
• Monad Array

class (Eq a) <= Ord a  where

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

Ord instances should satisfy the laws of total orderings:

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

Members

• compare :: a -> a -> Ordering

Instances

• Ord Boolean
• Ord Int
• Ord Number
• Ord String
• Ord Char
• Ord Unit
• Ord Void
• (Ord a) => Ord (Array a)
• Ord Ordering

class (Semiring a) <= Ring a  where

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

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

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

Members

• sub :: a -> a -> a

Instances

• Ring Int
• Ring Number
• Ring Unit
• (Ring b) => Ring (a -> b)

class Semigroup a  where

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

Instances are required to satisfy the following law:

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

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

Members

• append :: a -> a -> a

Instances

• Semigroup String
• Semigroup Unit
• Semigroup Void
• (Semigroup s') => Semigroup (s -> s')
• Semigroup (Array a)

class Semigroupoid a  where

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

Semigroupoids must satisfy the following law:

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

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

Members

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

Instances

• Semigroupoid Function

class Semiring a  where

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

Instances must satisfy the following laws:

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

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

Members

• add :: a -> a -> a
• zero :: a
• mul :: a -> a -> a
• one :: a

Instances

• Semiring Int
• Semiring Number
• (Semiring b) => Semiring (a -> b)
• Semiring Unit

class Show a  where

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

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

Members

• show :: a -> String

Instances

• Show Boolean
• Show Int
• Show Number
• Show Char
• Show String
• (Show a) => Show (Array a)

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

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

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

Perform an applicative action when a condition is true.

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

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

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

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

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

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

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

Perform an applicative action unless a condition is true.

unit :: Unit

unit is the sole inhabitant of the Unit type.

otherwise :: Boolean

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

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

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

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

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

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

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

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

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

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

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

liftM1 provides a default implementation of (<$>) for any Monad, without using (<$>) as provided by the Functor-Monad superclass relationship.

liftM1 can therefore be used to write Functor instances as follows:

instance functorF :: Functor F where
  map = liftM1

liftA1 :: forall b a f. Applicative f => (a -> b) -> f a -> f b

liftA1 provides a default implementation of (<$>) for any Applicative functor, without using (<$>) as provided by the Functor-Applicative superclass relationship.

liftA1 can therefore be used to write Functor instances as follows:

instance functorF :: Functor F where
  map = liftA1

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

The least common multiple of two values.

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

Collapse two applications of a monadic type constructor into one.

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

Execute a monadic action if a condition holds.

For example:

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

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

The greatest common divisor of two values.

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

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

flip const 1 2 = const 2 1 = 2

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

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

Generalizes flip.

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

validate :: String -> List Bool
validate = flap [longEnough, hasSymbol, hasDigit]

flap (-) 3 4 == 1
threeve <$> Just 1 <@> 'a' <*> Just true == Just (threeve 1 'a' true)

discard :: forall a f. Apply f => f Unit -> (Unit -> f a) -> f a

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

Returns its first argument and ignores its second.

const 1 "hello" = 1

compose :: forall a d c b. Semigroupoid a => a c d -> a b c -> a b d

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

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

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

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

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

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

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

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

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

append :: forall a. Semigroup a => a -> a -> a

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

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

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

instance applyF :: Apply F where
  apply = ap

absurd :: forall a. Void -> a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Operator alias for Paxl.Prelude.ApplyRowEffect (right-associative / precedence 0)

Operator alias for Paxl.Prelude.ApplyRowType (right-associative / precedence 0)

runPaxl :: forall m a eff req. MonadAff ((GenPaxlEffects req) :+ eff) m => Env req -> GenPaxl req a -> m a

initEnv :: forall m eff reqEff env req. MonadEff (ref :: REF | eff) m => Fetchable req env reqEff => env -> m (Env req)