Module

InteractiveData.Core.Prelude

Package: purescript-interactive-data
Repository: thought2/purescript-interactive-data.all

Re-exports from Chameleon.Styled

#StyleT Source

newtype StyleT :: (Type -> Type) -> Type -> Typenewtype StyleT html a

Instances

FunctorTrans StyleT
(Functor html) => Functor (StyleT html)
(Html html) => Html (StyleT html)
(Html html) => MapMaybe (StyleT html)
(Html html) => HtmlStyled (StyleT html)
(TellAccum acc html) => TellAccum acc (StyleT html)
(Accum acc html) => Accum acc (StyleT html)
(OutMsg out html) => OutMsg out (StyleT html)
(RunOutMsg out html) => RunOutMsg out (StyleT html)

#StyleMap Source

newtype StyleMap

#StyleDecl Source

newtype StyleDecl

Instances

#Style Source

newtype Style

Instances

#InlineStyle Source

newtype InlineStyle

Constructors

InlineStyle String

Instances

Newtype InlineStyle _

#ClassName Source

newtype ClassName

Constructors

ClassName String

Instances

#HtmlStyled Source

class HtmlStyled :: (Type -> Type) -> Constraintclass (Html html) <= HtmlStyled (html :: Type -> Type)  where

Members

registerStyleMap :: forall msg. StyleMap -> html msg -> html msg

Instances

(Html html) => HtmlStyled (StyleT html)
(HtmlStyled html) => HtmlStyled (CtxT ctx html)

#IsStyle Source

class IsStyle a  where

Members

toStyle :: a -> Style

Instances

IsStyle Style
IsStyle String
IsStyle Unit
(IsStyle a) => IsStyle (Array a)
IsStyle ClassName
IsStyle StyleDecl
IsStyle Anim
(IsStyle a, IsStyle b) => IsStyle (Tuple a b)

#mergeDecl Source

mergeDecl :: forall a. IsDecl a => a -> String

#styleNode Source

styleNode :: forall html style a. Html html => HtmlStyled html => IsStyle style => ElemNode html a -> style -> ElemNode html a

#styleLeaf Source

styleLeaf :: forall html style a. Html html => HtmlStyled html => IsStyle style => ElemLeaf html a -> style -> ElemLeaf html a

#styleKeyedNode Source

styleKeyedNode :: forall html style a. Html html => HtmlStyled html => IsStyle style => ElemKeyedNode html a -> style -> ElemKeyedNode html a

#styleKeyedLeaf Source

styleKeyedLeaf :: forall html style a. Html html => HtmlStyled html => IsStyle style => ElemKeyedLeaf html a -> style -> ElemKeyedLeaf html a

#runStyleT Source

runStyleT :: forall html a. Html html => StyleT html a -> html a

#declWith Source

declWith :: forall decl. IsDecl decl => String -> decl -> StyleDecl

#decl Source

decl :: forall decl. IsDecl decl => decl -> StyleDecl

#anim Source

anim :: String -> Array (String /\ (Array String)) -> Anim

Re-exports from Chameleon.Transformers.Ctx.Class

#AskCtx Source

class AskCtx :: Type -> (Type -> Type) -> Constraintclass AskCtx ctx html | html -> ctx where

Members

withCtx :: forall a. (ctx -> html a) -> html a

#Ctx Source

class Ctx :: Type -> (Type -> Type) -> Constraintclass (AskCtx ctx html) <= Ctx ctx html | html -> ctx where

Members

setCtx :: forall a. (ctx -> ctx) -> html a -> html a

#putCtx Source

putCtx :: forall a html ctx. Ctx ctx html => ctx -> html a -> html a

Re-exports from Data.Either

#Either Source

data Either a b

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

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

Constructors

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)

#note' Source

note' :: forall a b. (Unit -> a) -> Maybe b -> Either a b

Similar to note, but for use in cases where the default value may be expensive to compute.

note' (\_ -> "default") Nothing = Left "default"
note' (\_ -> "default") (Just 1) = Right 1

#note Source

note :: forall a b. a -> Maybe b -> Either a b

Takes a default and a Maybe value, if the value is a Just, turn it into a Right, if the value is a Nothing use the provided default as a Left

note "default" Nothing = Left "default"
note "default" (Just 1) = Right 1

#isRight Source

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

Returns true when the Either value was constructed with Right.

#isLeft Source

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

Returns true when the Either value was constructed with Left.

#hush Source

hush :: forall a b. Either a b -> Maybe b

Turns an Either into a Maybe, by throwing potential Left values away and converting them into Nothing. Right values get turned into Justs.

hush (Left "ParseError") = Nothing
hush (Right 42) = Just 42

#fromRight' Source

fromRight' :: forall a b. (Unit -> b) -> Either a b -> b

Similar to fromRight but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromRight has to evaluate the default value before returning the result, whereas here the value is only computed when the Either is known to be Left.

#fromRight Source

fromRight :: forall a b. b -> Either a b -> b

A function that extracts the value from the Right data constructor. The first argument is a default value, which will be returned in the case where a Left is passed to fromRight.

#fromLeft' Source

fromLeft' :: forall a b. (Unit -> a) -> Either a b -> a

Similar to fromLeft but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromLeft has to evaluate the default value before returning the result, whereas here the value is only computed when the Either is known to be Right.

#fromLeft Source

fromLeft :: forall a b. a -> Either a b -> a

A function that extracts the value from the Left data constructor. The first argument is a default value, which will be returned in the case where a Right is passed to fromLeft.

#either Source

either :: forall a b c. (a -> c) -> (b -> c) -> Either a b -> c

Takes two functions and an Either value, if the value is a Left the inner value is applied to the first function, if the value is a Right the inner value is applied to the second function.

either f g (Left x) == f x
either f g (Right y) == g y

#choose Source

choose :: forall m a b. Alt m => m a -> m b -> m (Either a b)

Combine two alternatives.

#blush Source

blush :: forall a b. Either a b -> Maybe a

Turns an Either into a Maybe, by throwing potential Right values away and converting them into Nothing. Left values get turned into Justs.

blush (Left "ParseError") = Just "Parse Error"
blush (Right 42) = Nothing

Re-exports from Data.Eq

#Eq1 Source

class Eq1 :: (Type -> Type) -> Constraintclass Eq1 f  where

The Eq1 type class represents type constructors with decidable equality.

Members

eq1 :: forall a. Eq a => f a -> f a -> Boolean

Instances

Eq1 Array

#EqRecord Source

class EqRecord :: RowList Type -> Row Type -> Constraintclass EqRecord rowlist row  where

A class for records where all fields have Eq instances, used to implement the Eq instance for records.

Members

eqRecord :: Proxy rowlist -> Record row -> Record row -> Boolean

Instances

EqRecord Nil row
(EqRecord rowlistTail row, Cons key focus rowTail row, IsSymbol key, Eq focus) => EqRecord (Cons key focus rowlistTail) row

#notEq1 Source

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

Re-exports from Data.Generic.Rep

#Sum Source

data Sum a b

A representation for types with multiple constructors.

Constructors

Inl a
Inr b

Instances

(Show a, Show b) => Show (Sum a b)

#Product Source

data Product a b

A representation for constructors with multiple fields.

Constructors

Product a b

Instances

(Show a, Show b) => Show (Product a b)

#NoConstructors Source

newtype NoConstructors

A representation for types with no constructors.

#NoArguments Source

data NoArguments

A representation for constructors with no arguments.

Constructors

NoArguments

Instances

Show NoArguments

#Constructor Source

newtype Constructor :: Symbol -> Type -> Typenewtype Constructor (name :: Symbol) a

A representation for constructors which includes the data constructor name as a type-level string.

Constructors

Constructor a

Instances

(IsSymbol name, Show a) => Show (Constructor name a)

#Argument Source

newtype Argument a

A representation for an argument in a data constructor.

Constructors

Argument a

Instances

(Show a) => Show (Argument a)

#Generic Source

class Generic a rep | a -> rep where

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

Members

to :: rep -> a
from :: a -> rep

#repOf Source

repOf :: forall a rep. Generic a rep => Proxy a -> Proxy rep

Re-exports from Data.Identity

#Identity Source

newtype Identity a

Constructors

Identity a

Instances

Newtype (Identity a) _
(Eq a) => Eq (Identity a)
(Ord a) => Ord (Identity a)
(Bounded a) => Bounded (Identity a)
(HeytingAlgebra a) => HeytingAlgebra (Identity a)
(BooleanAlgebra a) => BooleanAlgebra (Identity a)
(Semigroup a) => Semigroup (Identity a)
(Monoid a) => Monoid (Identity a)
(Semiring a) => Semiring (Identity a)
(EuclideanRing a) => EuclideanRing (Identity a)
(Ring a) => Ring (Identity a)
(CommutativeRing a) => CommutativeRing (Identity a)
(Lazy a) => Lazy (Identity a)
(Show a) => Show (Identity a)
Eq1 Identity
Ord1 Identity
Functor Identity
Invariant Identity
Alt Identity
Apply Identity
Applicative Identity
Bind Identity
Monad Identity
Extend Identity
Comonad Identity

Re-exports from Data.Maybe

#Maybe Source

data Maybe a

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

Constructors

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

#optional Source

optional :: forall f a. Alt f => Applicative f => f a -> f (Maybe a)

One or none.

optional empty = pure Nothing

The behaviour of optional (pure x) depends on whether the Alt instance satisfy the left catch law (pure a <|> b = pure a).

Either e does:

optional (Right x) = Right (Just x)

But Array does not:

optional [x] = [Just x, Nothing]

#maybe' Source

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

Similar to maybe but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard maybe has to evaluate the default value before returning the result, whereas here the value is only computed when the Maybe is known to be Nothing.

maybe' (\_ -> x) f Nothing == x
maybe' (\_ -> x) f (Just y) == f y

#maybe Source

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

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

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

#isNothing Source

isNothing :: forall a. Maybe a -> Boolean

Returns true when the Maybe value is Nothing.

#isJust Source

isJust :: forall a. Maybe a -> Boolean

Returns true when the Maybe value was constructed with Just.

#fromMaybe' Source

fromMaybe' :: forall a. (Unit -> a) -> Maybe a -> a

Similar to fromMaybe but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromMaybe has to evaluate the default value before returning the result, whereas here the value is only computed when the Maybe is known to be Nothing.

fromMaybe' (\_ -> x) Nothing == x
fromMaybe' (\_ -> x) (Just y) == y

#fromMaybe Source

fromMaybe :: forall a. a -> Maybe a -> a

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

fromMaybe x Nothing == x
fromMaybe x (Just y) == y

#fromJust Source

fromJust :: forall a. Partial => Maybe a -> a

A partial function that extracts the value from the Just data constructor. Passing Nothing to fromJust will throw an error at runtime.

Re-exports from Data.Newtype

#Newtype Source

class (Coercible t a) <= Newtype t a | t -> a

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

The compiler can derive instances of Newtype automatically:

newtype EmailAddress = EmailAddress String

derive instance newtypeEmailAddress :: Newtype EmailAddress _

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

Instances

Newtype (Additive a) a
Newtype (Multiplicative a) a
Newtype (Conj a) a
Newtype (Disj a) a
Newtype (Dual a) a
Newtype (Endo c a) (c a a)
Newtype (First a) a
Newtype (Last a) a

#wrap Source

wrap :: forall t a. Newtype t a => a -> t

#unwrap Source

unwrap :: forall t a. Newtype t a => t -> a

#un Source

un :: forall t a. Newtype t a => (a -> t) -> t -> a

Given a constructor for a Newtype, this returns the appropriate unwrap function.

Re-exports from Data.Ord

#Ord1 Source

class Ord1 :: (Type -> Type) -> Constraintclass (Eq1 f) <= Ord1 f  where

The Ord1 type class represents totally ordered type constructors.

Members

compare1 :: forall a. Ord a => f a -> f a -> Ordering

Instances

Ord1 Array

#OrdRecord Source

class OrdRecord :: RowList Type -> Row Type -> Constraintclass (EqRecord rowlist row) <= OrdRecord rowlist row  where

Members

compareRecord :: Proxy rowlist -> Record row -> Record row -> Ordering

Instances

OrdRecord Nil row
(OrdRecord rowlistTail row, Cons key focus rowTail row, IsSymbol key, Ord focus) => OrdRecord (Cons key focus rowlistTail) row

#signum Source

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

The sign function; returns one if the argument is positive, negate one if the argument is negative, or zero if the argument is zero. For floating point numbers with signed zeroes, when called with a zero, this function returns the argument in order to preserve the sign. For any x, we should have signum x * abs x == x.

#lessThanOrEq Source

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

Test whether one value is non-strictly less than another.

#lessThan Source

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

Test whether one value is strictly less than another.

#greaterThanOrEq Source

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

Test whether one value is non-strictly greater than another.

#greaterThan Source

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

Test whether one value is strictly greater than another.

#abs Source

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

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

Re-exports from Data.Show.Generic

#GenericShow Source

class GenericShow a  where

Members

genericShow' :: a -> String

Instances

GenericShow NoConstructors
(GenericShow a, GenericShow b) => GenericShow (Sum a b)
(GenericShowArgs a, IsSymbol name) => GenericShow (Constructor name a)

#GenericShowArgs Source

class GenericShowArgs a  where

Members

genericShowArgs :: a -> Array String

Instances

GenericShowArgs NoArguments
(GenericShowArgs a, GenericShowArgs b) => GenericShowArgs (Product a b)
(Show a) => GenericShowArgs (Argument a)

#genericShow Source

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

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

Re-exports from Data.These

#These Source

data These a b

Data type isomorphic to α ∨ β ∨ (α ∧ β) or Either a (Either b (Tuple a b)).

Constructors

This a
That b
Both a b

Instances

(Eq a, Eq b) => Eq (These a b)
(Ord a, Ord b) => Ord (These a b)
(Semigroup a, Semigroup b) => Semigroup (These a b)
Functor (These a)
Invariant (These a)
Foldable (These a)
Traversable (These a)
Bifunctor These
Bifoldable These
Bitraversable These
(Semigroup a) => Apply (These a)
(Semigroup a) => Applicative (These a)
(Semigroup a) => Bind (These a)
(Semigroup a) => Monad (These a)
Extend (These a)
(Show a, Show b) => Show (These a b)

#thisOrBoth Source

thisOrBoth :: forall a b. a -> Maybe b -> These a b

#this Source

this :: forall a b. These a b -> Maybe a

Returns the a value if and only if the value is constructed with This.

#theseRight Source

theseRight :: forall a b. These a b -> Maybe b

Returns a b value if possible.

#theseLeft Source

theseLeft :: forall a b. These a b -> Maybe a

Returns an a value if possible.

#these Source

these :: forall a b c. (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c

Given functions to handle each constructor, collapse a These value into single value.

#thatOrBoth Source

thatOrBoth :: forall a b. b -> Maybe a -> These a b

#that Source

that :: forall a b. These a b -> Maybe b

Returns the b value if and only if the value is constructed with That.

#swap Source

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

Swap between This and That, and flips the order for Both.

#maybeThese Source

maybeThese :: forall a b. Maybe a -> Maybe b -> Maybe (These a b)

Takes a pair of Maybes and attempts to create a These from them.

#isThis Source

isThis :: forall a b. These a b -> Boolean

Returns true when the These value is This

#isThat Source

isThat :: forall a b. These a b -> Boolean

Returns true when the These value is That

#isBoth Source

isBoth :: forall a b. These a b -> Boolean

Returns true when the These value is Both

#fromThese Source

fromThese :: forall a b. a -> b -> These a b -> Tuple a b

Takes two default values and a These value. If the These value is This or That, the value wrapped in the These value and its corresponding default value are wrapped into a Tuple. Otherwise, the values stored in the Both are rewrapped into a Tuple.

#both Source

both :: forall a b. These a b -> Maybe (Tuple a b)

Returns the a and b values if and only if they are constructed with Both.

#assoc Source

assoc :: forall a b c. These (These a b) c -> These a (These b c)

Re-associate These from left to right.

Re-exports from Data.Tuple.Nested

#Tuple9 Source

type Tuple9 a b c d e f g h i = T10 a b c d e f g h i Unit

#Tuple8 Source

type Tuple8 a b c d e f g h = T9 a b c d e f g h Unit

#Tuple7 Source

type Tuple7 a b c d e f g = T8 a b c d e f g Unit

#Tuple6 Source

type Tuple6 a b c d e f = T7 a b c d e f Unit

#Tuple5 Source

type Tuple5 a b c d e = T6 a b c d e Unit

#Tuple4 Source

type Tuple4 a b c d = T5 a b c d Unit

#Tuple3 Source

type Tuple3 a b c = T4 a b c Unit

#Tuple2 Source

type Tuple2 a b = T3 a b Unit

#Tuple10 Source

type Tuple10 a b c d e f g h i j = T11 a b c d e f g h i j Unit

#Tuple1 Source

type Tuple1 a = T2 a Unit

#T9 Source

type T9 a b c d e f g h z = Tuple a (T8 b c d e f g h z)

#T8 Source

type T8 a b c d e f g z = Tuple a (T7 b c d e f g z)

#T7 Source

type T7 a b c d e f z = Tuple a (T6 b c d e f z)

#T6 Source

type T6 a b c d e z = Tuple a (T5 b c d e z)

#T5 Source

type T5 a b c d z = Tuple a (T4 b c d z)

#T4 Source

type T4 a b c z = Tuple a (T3 b c z)

#T3 Source

type T3 a b z = Tuple a (T2 b z)

#T2 Source

type T2 a z = Tuple a z

#T11 Source

type T11 a b c d e f g h i j z = Tuple a (T10 b c d e f g h i j z)

#T10 Source

type T10 a b c d e f g h i z = Tuple a (T9 b c d e f g h i z)

#uncurry9 Source

uncurry9 :: forall a b c d e f g h i r z. (a -> b -> c -> d -> e -> f -> g -> h -> i -> r) -> T10 a b c d e f g h i z -> r

Given a function of 9 arguments, returns a function that accepts a 9-tuple.

#uncurry8 Source

uncurry8 :: forall a b c d e f g h r z. (a -> b -> c -> d -> e -> f -> g -> h -> r) -> T9 a b c d e f g h z -> r

Given a function of 8 arguments, returns a function that accepts an 8-tuple.

#uncurry7 Source

uncurry7 :: forall a b c d e f g r z. (a -> b -> c -> d -> e -> f -> g -> r) -> T8 a b c d e f g z -> r

Given a function of 7 arguments, returns a function that accepts a 7-tuple.

#uncurry6 Source

uncurry6 :: forall a b c d e f r z. (a -> b -> c -> d -> e -> f -> r) -> T7 a b c d e f z -> r

Given a function of 6 arguments, returns a function that accepts a 6-tuple.

#uncurry5 Source

uncurry5 :: forall a b c d e r z. (a -> b -> c -> d -> e -> r) -> T6 a b c d e z -> r

Given a function of 5 arguments, returns a function that accepts a 5-tuple.

#uncurry4 Source

uncurry4 :: forall a b c d r z. (a -> b -> c -> d -> r) -> T5 a b c d z -> r

Given a function of 4 arguments, returns a function that accepts a 4-tuple.

#uncurry3 Source

uncurry3 :: forall a b c r z. (a -> b -> c -> r) -> T4 a b c z -> r

Given a function of 3 arguments, returns a function that accepts a 3-tuple.

#uncurry2 Source

uncurry2 :: forall a b r z. (a -> b -> r) -> T3 a b z -> r

Given a function of 2 arguments, returns a function that accepts a 2-tuple.

#uncurry10 Source

uncurry10 :: forall a b c d e f g h i j r z. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> r) -> T11 a b c d e f g h i j z -> r

Given a function of 10 arguments, returns a function that accepts a 10-tuple.

#uncurry1 Source

uncurry1 :: forall a r z. (a -> r) -> T2 a z -> r

Given a function of 1 argument, returns a function that accepts a singleton tuple.

#tuple9 Source

tuple9 :: forall a b c d e f g h i. a -> b -> c -> d -> e -> f -> g -> h -> i -> Tuple9 a b c d e f g h i

Given 9 values, creates a nested 9-tuple.

#tuple8 Source

tuple8 :: forall a b c d e f g h. a -> b -> c -> d -> e -> f -> g -> h -> Tuple8 a b c d e f g h

Given 8 values, creates a nested 8-tuple.

#tuple7 Source

tuple7 :: forall a b c d e f g. a -> b -> c -> d -> e -> f -> g -> Tuple7 a b c d e f g

Given 7 values, creates a nested 7-tuple.

#tuple6 Source

tuple6 :: forall a b c d e f. a -> b -> c -> d -> e -> f -> Tuple6 a b c d e f

Given 6 values, creates a nested 6-tuple.

#tuple5 Source

tuple5 :: forall a b c d e. a -> b -> c -> d -> e -> Tuple5 a b c d e

Given 5 values, creates a nested 5-tuple.

#tuple4 Source

tuple4 :: forall a b c d. a -> b -> c -> d -> Tuple4 a b c d

Given 4 values, creates a nested 4-tuple.

#tuple3 Source

tuple3 :: forall a b c. a -> b -> c -> Tuple3 a b c

Given 3 values, creates a nested 3-tuple.

#tuple2 Source

tuple2 :: forall a b. a -> b -> Tuple2 a b

Given 2 values, creates a 2-tuple.

#tuple10 Source

tuple10 :: forall a b c d e f g h i j. a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> Tuple10 a b c d e f g h i j

Given 10 values, creates a nested 10-tuple.

#tuple1 Source

tuple1 :: forall a. a -> Tuple1 a

Creates a singleton tuple.

#over9 Source

over9 :: forall a b c d e f g h i r z. (i -> r) -> T10 a b c d e f g h i z -> T10 a b c d e f g h r z

Given at least a 9-tuple, modifies the ninth value.

#over8 Source

over8 :: forall a b c d e f g h r z. (h -> r) -> T9 a b c d e f g h z -> T9 a b c d e f g r z

Given at least an 8-tuple, modifies the eighth value.

#over7 Source

over7 :: forall a b c d e f g r z. (g -> r) -> T8 a b c d e f g z -> T8 a b c d e f r z

Given at least a 7-tuple, modifies the seventh value.

#over6 Source

over6 :: forall a b c d e f r z. (f -> r) -> T7 a b c d e f z -> T7 a b c d e r z

Given at least a 6-tuple, modifies the sixth value.

#over5 Source

over5 :: forall a b c d e r z. (e -> r) -> T6 a b c d e z -> T6 a b c d r z

Given at least a 5-tuple, modifies the fifth value.

#over4 Source

over4 :: forall a b c d r z. (d -> r) -> T5 a b c d z -> T5 a b c r z

Given at least a 4-tuple, modifies the fourth value.

#over3 Source

over3 :: forall a b c r z. (c -> r) -> T4 a b c z -> T4 a b r z

Given at least a 3-tuple, modifies the third value.

#over2 Source

over2 :: forall a b r z. (b -> r) -> T3 a b z -> T3 a r z

Given at least a 2-tuple, modifies the second value.

#over10 Source

over10 :: forall a b c d e f g h i j r z. (j -> r) -> T11 a b c d e f g h i j z -> T11 a b c d e f g h i r z

Given at least a 10-tuple, modifies the tenth value.

#over1 Source

over1 :: forall a r z. (a -> r) -> T2 a z -> T2 r z

Given at least a singleton tuple, modifies the first value.

#get9 Source

get9 :: forall a b c d e f g h i z. T10 a b c d e f g h i z -> i

Given at least a 9-tuple, gets the ninth value.

#get8 Source

get8 :: forall a b c d e f g h z. T9 a b c d e f g h z -> h

Given at least an 8-tuple, gets the eigth value.

#get7 Source

get7 :: forall a b c d e f g z. T8 a b c d e f g z -> g

Given at least a 7-tuple, gets the seventh value.

#get6 Source

get6 :: forall a b c d e f z. T7 a b c d e f z -> f

Given at least a 6-tuple, gets the sixth value.

#get5 Source

get5 :: forall a b c d e z. T6 a b c d e z -> e

Given at least a 5-tuple, gets the fifth value.

#get4 Source

get4 :: forall a b c d z. T5 a b c d z -> d

Given at least a 4-tuple, gets the fourth value.

#get3 Source

get3 :: forall a b c z. T4 a b c z -> c

Given at least a 3-tuple, gets the third value.

#get2 Source

get2 :: forall a b z. T3 a b z -> b

Given at least a 2-tuple, gets the second value.

#get10 Source

get10 :: forall a b c d e f g h i j z. T11 a b c d e f g h i j z -> j

Given at least a 10-tuple, gets the tenth value.

#get1 Source

get1 :: forall a z. T2 a z -> a

Given at least a singleton tuple, gets the first value.

#curry9 Source

curry9 :: forall a b c d e f g h i r z. z -> (T10 a b c d e f g h i z -> r) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> r

Given a function that accepts at least a 9-tuple, returns a function of 9 arguments.

#curry8 Source

curry8 :: forall a b c d e f g h r z. z -> (T9 a b c d e f g h z -> r) -> a -> b -> c -> d -> e -> f -> g -> h -> r

Given a function that accepts at least an 8-tuple, returns a function of 8 arguments.

#curry7 Source

curry7 :: forall a b c d e f g r z. z -> (T8 a b c d e f g z -> r) -> a -> b -> c -> d -> e -> f -> g -> r

Given a function that accepts at least a 7-tuple, returns a function of 7 arguments.

#curry6 Source

curry6 :: forall a b c d e f r z. z -> (T7 a b c d e f z -> r) -> a -> b -> c -> d -> e -> f -> r

Given a function that accepts at least a 6-tuple, returns a function of 6 arguments.

#curry5 Source

curry5 :: forall a b c d e r z. z -> (T6 a b c d e z -> r) -> a -> b -> c -> d -> e -> r

Given a function that accepts at least a 5-tuple, returns a function of 5 arguments.

#curry4 Source

curry4 :: forall a b c d r z. z -> (T5 a b c d z -> r) -> a -> b -> c -> d -> r

Given a function that accepts at least a 4-tuple, returns a function of 4 arguments.

#curry3 Source

curry3 :: forall a b c r z. z -> (T4 a b c z -> r) -> a -> b -> c -> r

Given a function that accepts at least a 3-tuple, returns a function of 3 arguments.

#curry2 Source

curry2 :: forall a b r z. z -> (T3 a b z -> r) -> a -> b -> r

Given a function that accepts at least a 2-tuple, returns a function of 2 arguments.

#curry10 Source

curry10 :: forall a b c d e f g h i j r z. z -> (T11 a b c d e f g h i j z -> r) -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> r

Given a function that accepts at least a 10-tuple, returns a function of 10 arguments.

#curry1 Source

curry1 :: forall a r z. z -> (T2 a z -> r) -> a -> r

Given a function that accepts at least a singleton tuple, returns a function of 1 argument.

#(/\) Source

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

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

#type (/\) Source

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

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

Re-exports from DataMVC.Types

#DataUiInterface Source

newtype DataUiInterface :: (Type -> Type) -> Type -> Type -> Type -> Typenewtype DataUiInterface srf msg sta a

Constructors

DataUiInterface { extract :: sta -> DataResult a, init :: Maybe a -> sta, name :: String, update :: msg -> sta -> sta, view :: sta -> srf msg }

Instances

Newtype (DataUiInterface srf msg sta a) _

#DataUICtx Source

newtype DataUICtx :: (Type -> Type) -> (Type -> Type) -> (Type -> Type) -> Typenewtype DataUICtx html fm fs

Constructors

DataUICtx (DataUICtxImpl html fm fs)

#DataUI Source

newtype DataUI :: (Type -> Type) -> (Type -> Type) -> (Type -> Type) -> Type -> Type -> Type -> Typenewtype DataUI srf fm fs msg sta a

Constructors

DataUI (DataUICtx srf fm fs -> DataUiInterface srf msg sta a)

Instances

Newtype (DataUI srf fm fs msg sta a) _

#DataResult Source

type DataResult a = Either (NonEmptyArray DataError) a

#DataPathSegmentField Source

data DataPathSegmentField

Constructors

Instances

#DataPathSegment Source

data DataPathSegment

Constructors

Instances

#DataPath Source

type DataPath = Array DataPathSegment

#DataErrorCase Source

data DataErrorCase

Constructors

Instances

Re-exports from DataMVC.Types.DataError

#DataError Source

data DataError

Constructors

DataError DataPath DataErrorCase

Instances

Re-exports from InteractiveData.Core

#ViewMode Source

data ViewMode

Constructors

Inline
Standalone

Instances

#TreeMeta Source

type TreeMeta = { errored :: DataResult Unit, typeName :: String }

#PathInContext Source

type PathInContext a = { before :: Array a, path :: Array a }

#IDViewCtx Source

type IDViewCtx = { fastForward :: Boolean, fullscreen :: Boolean, path :: DataPath, root :: String /\ TreeMeta, selectedPath :: DataPath, showLogo :: Boolean, viewMode :: ViewMode }

#IDSurfaceCtx Source

type IDSurfaceCtx = { path :: DataPath }

#IDSurface Source

newtype IDSurface :: (Type -> Type) -> Type -> Typenewtype IDSurface html msg

Constructors

IDSurface (IDSurfaceCtx -> DataTree html msg)

Instances

(Functor html) => Functor (IDSurface html)
Newtype (IDSurface html msg) _

#IDOutMsg Source

data IDOutMsg

Constructors

GlobalSelectDataPath (Array String)

Instances

Ord IDOutMsg
Eq IDOutMsg

#DataTreeChildren Source

data DataTreeChildren :: (Type -> Type) -> Type -> Typedata DataTreeChildren srf msg

Constructors

Fields (Array (DataPathSegmentField /\ (DataTree srf msg)))
Case (String /\ (DataTree srf msg))

Instances

(Functor srf) => Functor (DataTreeChildren srf)
(Eq1 srf, Eq (srf msg), Eq msg) => Eq (DataTreeChildren srf msg)
(Ord (srf msg), Ord1 srf, Ord msg) => Ord (DataTreeChildren srf msg)

#DataTree Source

newtype DataTree :: (Type -> Type) -> Type -> Typenewtype DataTree srf msg

Constructors

DataTree { actions :: Array (DataAction msg), children :: DataTreeChildren srf msg, meta :: Maybe TreeMeta, text :: Maybe String, view :: srf msg }

Instances

Newtype (DataTree srf msg) _
Generic (DataTree srf msg) _
(Functor srf) => Functor (DataTree srf)
(Eq1 srf, Eq (srf msg), Eq msg) => Eq (DataTree srf msg)
(Ord (srf msg), Ord1 srf, Ord msg) => Ord (DataTree srf msg)
Show (DataTree srf msg)

#DataAction Source

newtype DataAction msg

Constructors

DataAction { description :: String, label :: String, msg :: These msg IDOutMsg }

Instances

Functor DataAction
(Eq msg) => Eq (DataAction msg)
(Ord msg) => Ord (DataAction msg)

#IDHtml Source

class IDHtml :: (Type -> Type) -> Constraintclass (Html html, Ctx IDViewCtx html, RunOutMsg IDOutMsg html, HtmlStyled html) <= IDHtml html

Re-exports from InteractiveData.Core.Classes.OptArgs

#NoConvert Source

data NoConvert

Instances

ConvertOption NoConvert sym a a

#OptArgs Source

class OptArgs all given  where

Members

getAllArgs :: all -> given -> all

Instances

(ConvertOptionsWithDefaults NoConvert all given all) => OptArgs all given

#OptArgsMixed Source

class OptArgsMixed :: Type -> Row Type -> Type -> Constraintclass OptArgsMixed all defaults given | all -> defaults given where

Members

getAllArgsMixed :: Record defaults -> given -> all

Instances

(ConvertOptionsWithDefaults NoConvert (Record defaults) given all) => OptArgsMixed all defaults given

Re-exports from InteractiveData.Core.Util.RecordProjection

#pick Source

pick :: forall a b. Project a b => a -> b

Re-exports from Prelude

#Void Source

newtype Void

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

#Unit Source

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.

#Ordering Source

data Ordering

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

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

Constructors

LT
GT
EQ

Instances

#Applicative Source

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

#Apply Source

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

#Bind Source

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

#BooleanAlgebra Source

class (HeytingAlgebra a) <= BooleanAlgebra a

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

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

Excluded middle:
- a || not a = tt

Instances

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

#Bounded Source

class (Ord a) <= Bounded a  where

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

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

Bounded: bottom <= a <= top

Members

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)

#Category Source

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

#CommutativeRing Source

class (Ring a) <= CommutativeRing a

The CommutativeRing class is for rings where multiplication is commutative.

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

Commutative multiplication: a * b = b * a

Instances

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

#Discard Source

class Discard a  where

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

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

Members

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

Instances

Discard Unit
Discard (Proxy a)

#DivisionRing Source

class (Ring a) <= DivisionRing a  where

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

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

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

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

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

Members

recip :: a -> a

Instances

DivisionRing Number

#Eq Source

class Eq a  where

The Eq type class represents types which support decidable equality.

Eq instances should satisfy the following laws:

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

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

Members

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)
Eq (Proxy a)

#EuclideanRing Source

class (CommutativeRing a) <= EuclideanRing a  where

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

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

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

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

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

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

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

Members

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

Instances

EuclideanRing Int
EuclideanRing Number

#Field Source

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

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

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

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

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

Instances

(EuclideanRing a, DivisionRing a) => Field a

#Functor Source

class Functor :: (Type -> Type) -> Constraintclass Functor f  where

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

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

Instances must satisfy the following laws:

Identity: map identity = identity
Composition: map (f <<< g) = map f <<< map g

Members

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

Instances

#HeytingAlgebra Source

class HeytingAlgebra a  where

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

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

Members

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

Instances

HeytingAlgebra Boolean
HeytingAlgebra Unit
(HeytingAlgebra b) => HeytingAlgebra (a -> b)
HeytingAlgebra (Proxy a)
(RowToList row list, HeytingAlgebraRecord list row row) => HeytingAlgebra (Record row)

#Monad Source

class Monad :: (Type -> Type) -> Constraintclass (Applicative m, Bind m) <= Monad m

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

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

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

Instances

#Monoid Source

class (Semigroup m) <= Monoid m  where

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

Left unit: (mempty <> x) = x
Right unit: (x <> mempty) = x

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

Newtypes for Monoid

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

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

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

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

Members

mempty :: m

Instances

Monoid Unit
Monoid Ordering
(Monoid b) => Monoid (a -> b)
Monoid String
Monoid (Array a)
(RowToList row list, MonoidRecord list row row) => Monoid (Record row)

#Ord Source

class (Eq a) <= Ord a  where

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

Ord instances should satisfy the laws of total orderings:

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

Note: The Number type is not an entirely law abiding member of this class due to the presence of NaN, since NaN <= NaN evaluates to false

Members

compare :: a -> a -> Ordering

Instances

Ord Boolean
Ord Int
Ord Number
Ord String
Ord Char
Ord Unit
Ord Void
Ord (Proxy a)
(Ord a) => Ord (Array a)
Ord Ordering
(RowToList row list, OrdRecord list row) => Ord (Record row)

#Ring Source

class (Semiring a) <= Ring a  where

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

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

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

Members

sub :: a -> a -> a

Instances

Ring Int
Ring Number
Ring Unit
(Ring b) => Ring (a -> b)
Ring (Proxy a)
(RowToList row list, RingRecord list row row) => Ring (Record row)

#Semigroup Source

class Semigroup a  where

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

Instances are required to satisfy the following law:

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

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

Newtypes for Semigroup

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

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

Members

append :: a -> a -> a

Instances

Semigroup String
Semigroup Unit
Semigroup Void
(Semigroup s') => Semigroup (s -> s')
Semigroup (Array a)
Semigroup (Proxy a)
(RowToList row list, SemigroupRecord list row row) => Semigroup (Record row)

#Semigroupoid Source

class Semigroupoid :: forall k. (k -> k -> Type) -> Constraintclass Semigroupoid a  where

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

Semigroupoids must satisfy the following law:

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

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

Members

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

Instances

Semigroupoid Function

#Semiring Source

class Semiring a  where

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

Instances must satisfy the following laws:

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

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

Members

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

Instances

Semiring Int
Semiring Number
(Semiring b) => Semiring (a -> b)
Semiring Unit
Semiring (Proxy a)
(RowToList row list, SemiringRecord list row row) => Semiring (Record row)

#Show Source

class Show a  where

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

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

Members

show :: a -> String

Instances

Show Unit
Show Boolean
Show Int
Show Number
Show Char
Show String
(Show a) => Show (Array a)
Show (Proxy a)
Show Void
(Nub rs rs, RowToList rs ls, ShowRecordFields ls rs) => Show (Record rs)

#whenM Source

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

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

#when Source

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

Perform an applicative action when a condition is true.

#void Source

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

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

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

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

#unlessM Source

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

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

#unless Source

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

Perform an applicative action unless a condition is true.

#unit Source

unit :: Unit

unit is the sole inhabitant of the Unit type.

#otherwise Source

otherwise :: Boolean

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

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

#notEq Source

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

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

#negate Source

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

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

#min Source

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

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

#max Source

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

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

#liftM1 Source

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

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

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

instance functorF :: Functor F where
  map = liftM1

#liftA1 Source

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

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

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

instance functorF :: Functor F where
  map = liftA1

#lcm Source

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

The least common multiple of two values.

#join Source

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

Collapse two applications of a monadic type constructor into one.

#ifM Source

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

Execute a monadic action if a condition holds.

For example:

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

#gcd Source

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

The greatest common divisor of two values.

#flip Source

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

Given a function that takes two arguments, applies the arguments to the function in a swapped order.

flip append "1" "2" == append "2" "1" == "21"

const 1 "two" == 1

flip const 1 "two" == const "two" 1 == "two"

#flap Source

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

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

Generalizes flip.

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

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

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

#const Source

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

Returns its first argument and ignores its second.

const 1 "hello" = 1

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

const 1 = \_ -> 1

#comparing Source

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

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

#clamp Source

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

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

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

#between Source

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

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

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

#ap Source

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

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

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

instance applyF :: Apply F where
  apply = ap

#absurd Source

absurd :: forall a. Void -> a

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

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

#(||) Source

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

#(>>>) Source

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

#(>>=) Source

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

#(>=>) Source

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

#(>=) Source

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

#(>) Source

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

#(==) Source

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

#(=<<) Source

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

#(<@>) Source

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

#(<>) Source

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

#(<=<) Source

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

#(<=) Source

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

#(<<<) Source

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

#(<*>) Source

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

#(<*) Source

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

#(<$>) Source

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

#(<$) Source

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

#(<#>) Source

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

#(<) Source

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

#(/=) Source

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

#(/) Source

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

#(-) Source

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

#(+) Source

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

#(*>) Source

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

#(*) Source

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

#(&&) Source

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

#($>) Source

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

#($) Source

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

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

length $ groupBy productCategory $ filter isInStock $ products

is equivalent to:

length (groupBy productCategory (filter isInStock products))

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

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

#(#) Source

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

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

products # filter isInStock # groupBy productCategory # length

is equivalent to:

length (groupBy productCategory (filter isInStock products))

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

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

#type (~>) Source

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

Re-exports from Type.Row

#RowApply Source

type RowApply :: forall k. (Row k -> Row k) -> Row k -> Row ktype RowApply f a = f a

Type application for rows.

#Cons

class Cons (label :: Symbol) (a :: k) (tail :: Row k) (row :: Row k) | label a tail -> row, label row -> a tail

The Cons type class is a 4-way relation which asserts that one row of types can be obtained from another by inserting a new label/type pair on the left.

#Lacks

class Lacks (label :: Symbol) (row :: Row k)

The Lacks type class asserts that a label does not occur in a given row.

#Nub

class Nub (original :: Row k) (nubbed :: Row k) | original -> nubbed

The Nub type class is used to remove duplicate labels from rows.

#Union

class Union (left :: Row k) (right :: Row k) (union :: Row k) | left right -> union, right union -> left, union left -> right

The Union type class is used to compute the union of two rows of types (left-biased, including duplicates).

The third type argument represents the union of the first two.

#type (+) Source

Operator alias for Type.Row.RowApply (right-associative / precedence 0)

Applies a type alias of open rows to a set of rows. The primary use case this operator is as convenient sugar for combining open rows without parentheses.

type Rows1 r = (a :: Int, b :: String | r)
type Rows2 r = (c :: Boolean | r)
type Rows3 r = (Rows1 + Rows2 + r)
type Rows4 r = (d :: String | Rows1 + Rows2 + r)

Modules: InteractiveData; InteractiveData.App; InteractiveData.App.EnvVars; InteractiveData.App.FastForward.Inline; InteractiveData.App.FastForward.Standalone; InteractiveData.App.Routing; InteractiveData.App.Types; InteractiveData.App.UI.ActionButton; InteractiveData.App.UI.Assets; InteractiveData.App.UI.Body; InteractiveData.App.UI.Breadcrumbs; InteractiveData.App.UI.Card; InteractiveData.App.UI.DataLabel; InteractiveData.App.UI.Footer; InteractiveData.App.UI.Header; InteractiveData.App.UI.Layout; InteractiveData.App.UI.Menu; InteractiveData.App.UI.NotFound; InteractiveData.App.UI.SideBar; InteractiveData.App.UI.Types.SumTree; InteractiveData.App.WrapApp; InteractiveData.App.WrapData; InteractiveData.Class; InteractiveData.Class.Defaults; InteractiveData.Class.Defaults.Generic; InteractiveData.Class.Defaults.Record; InteractiveData.Class.Defaults.Variant; InteractiveData.Class.InitDataUI; InteractiveData.Class.Partial; InteractiveData.Core; InteractiveData.Core.Classes.IDHtml; InteractiveData.Core.Classes.OptArgs; InteractiveData.Core.FeatureFlags; InteractiveData.Core.Prelude; InteractiveData.Core.Types.Common; InteractiveData.Core.Types.DataAction; InteractiveData.Core.Types.DataPathExtra; InteractiveData.Core.Types.DataTree; InteractiveData.Core.Types.IDHtmlT; InteractiveData.Core.Types.IDOutMsg; InteractiveData.Core.Types.IDSurface; InteractiveData.Core.Types.IDViewCtx; InteractiveData.Core.Util.RecordProjection; InteractiveData.DataUIs; InteractiveData.DataUIs.Array; InteractiveData.DataUIs.Boolean; InteractiveData.DataUIs.Common; InteractiveData.DataUIs.Generic; InteractiveData.DataUIs.Int; InteractiveData.DataUIs.Json; InteractiveData.DataUIs.Newtype; InteractiveData.DataUIs.Number; InteractiveData.DataUIs.Record; InteractiveData.DataUIs.String; InteractiveData.DataUIs.Trivial; InteractiveData.DataUIs.Types; InteractiveData.DataUIs.Variant; InteractiveData.Entry; InteractiveData.Run; InteractiveData.UI.NumberInput; InteractiveData.UI.Slider

InteractiveData.Core.Prelude

Re-exports from Chameleon.Styled

#StyleT Source

Instances

#StyleMap Source

#StyleDecl Source

Instances

#Style Source

Instances

#InlineStyle Source

Constructors

Instances

#ClassName Source

Constructors

Instances

#Anim Source

Instances

#HtmlStyled Source

Members

Instances

#IsStyle Source

Members

Instances

#mergeDecl Source

#styleNode Source

#styleLeaf Source

#styleKeyedNode Source

#styleKeyedLeaf Source

#runStyleT Source

#declWith Source

#decl Source

#anim Source

Re-exports from Chameleon.Transformers.Ctx.Class

#AskCtx Source

Members

#Ctx Source

Members

#putCtx Source

Re-exports from Data.Either

#Either Source

Constructors

Instances

#note' Source

#note Source

#isRight Source

#isLeft Source

#hush Source

#fromRight' Source

#fromRight Source

#fromLeft' Source

#fromLeft Source

#either Source

#choose Source

#blush Source

Re-exports from Data.Eq

#Eq1 Source

Members

Instances

#EqRecord Source

Members

Instances

#notEq1 Source

Re-exports from Data.Generic.Rep

#Sum Source

Constructors

Instances

#Product Source

Constructors

Instances

#NoConstructors Source

#NoArguments Source

Constructors

Instances

#Constructor Source

Constructors

Instances

#Argument Source

Constructors

Instances

#Generic Source