Module

Data.Refined

Package: purescript-refined
Repository: danieljharvey/purescript-refined

#Refined Source

newtype Refined p x

Constructors

Refined x

Instances

(Eq x) => Eq (Refined p x)
(Show x) => Show (Refined p x)
Generic (Refined p x) _
(DecodeJson x, Show x, Predicate p x) => DecodeJson (Refined p x)
(EncodeJson x) => EncodeJson (Refined p x)

#refine Source

refine :: forall x p. Predicate p x => x -> Either (RefinedError x) (Refined p x)

#unsafeRefine Source

unsafeRefine :: forall x p. Predicate p x => x -> (Refined p x)

#unrefine Source

unrefine :: forall x p. Refined p x -> x

Re-exports from Data.Refined.Error

#RefinedError Source

data RefinedError a

Constructors

AndError (These (RefinedError a) (RefinedError a))
OrError (RefinedError a) (RefinedError a)
SizeEqualToError Int a
SizeGreaterThanError Int a
SizeLessThanError Int a
NotError
LessThanError Int a
GreaterThanError Int a
FromError Int a
ToError Int a
FromToError Int Int a
EqualToError Int a
NotEqualToError Int a

Instances

(Eq a) => Eq (RefinedError a)
(Show a) => Show (RefinedError a)

Re-exports from Data.Refined.Internal

#These Source

data These a b

Helper version of function because i am too lazy to find the package

Constructors

This a
That b
These a b

Instances

(Eq a, Eq b) => Eq (These a b)
(Ord a, Ord b) => Ord (These a b)

#fromInt Source

fromInt :: forall a. Ring a => Int -> a

Re-exports from Data.Refined.Predicate

#ZeroToOne Source

type ZeroToOne = FromTo D0 D1

An inclusive range of values from zero to one.

#To Source

data To n

A 'Predicate' ensuring that the value is up and including a given int

Instances

(Nat n, Ord x, Ring x) => Predicate (To n) x

#SizeLessThan Source

data SizeLessThan a

A 'Predicate' ensuring that the length of a foldable is less than a given int

Instances

(Predicate a x, Foldable t, Nat n) => Predicate (SizeLessThan n) (t a)

#SizeGreaterThan Source

data SizeGreaterThan a

A 'Predicate' ensuring that the length of a foldable is greater than a given int

Instances

(Predicate a x, Foldable t, Nat n) => Predicate (SizeGreaterThan n) (t a)

#SizeEqualTo Source

data SizeEqualTo a

A 'Predicate' ensuring that the length of a foldable is equal to a given int

Instances

(Predicate a x, Foldable t, Nat n) => Predicate (SizeEqualTo n) (t a)

#Positive Source

type Positive = GreaterThan D0

A 'Predicate' ensuring that the value is greater than zero.

#Or Source

data Or l r

A 'Predicate' ensuring that one of two given Predicates is valid

Instances

(Predicate l x, Predicate r x) => Predicate (Or l r) x

#NotEqualTo Source

data NotEqualTo n

A 'Predicate' ensuring that the value is not equal to a given int

Instances

(Nat n, Eq x, Ring x) => Predicate (NotEqualTo n) x

#Not Source

data Not a

A 'Predicate' ensuring that the opposite of another Predicate passes

Instances

(Predicate a x) => Predicate (Not a) x

#NonZero Source

type NonZero = NotEqualTo D0

A 'Predicate' ensuring that the value is not equal to zero.

#NonNegative Source

type NonNegative = From D0

A 'Predicate' ensuring that the value is greater than or equal to zero.

#NonEmpty Source

type NonEmpty = SizeGreaterThan D0

A 'Predicate' ensuring that the 'Foldable' is non-empty.

#Negative Source

type Negative = LessThan D0

A 'Predicate' ensuring that the value is less than zero.

#LessThan Source

data LessThan n

A 'Predicate' ensuring that the value is less than a given int

Instances

(Nat n, Ord x, Ring x) => Predicate (LessThan n) x

#IdPred Source

data IdPred

A 'Predicate' for which everything is valid

Instances

Predicate IdPred x

#GreaterThan Source

data GreaterThan n

A 'Predicate' ensuring that the value is greater than a given int

Instances

(Nat n, Ord x, Ring x) => Predicate (GreaterThan n) x

#FromTo Source

data FromTo m n

A 'Predicate' ensuring that the value is between two given ints (inclusive)

Instances

(Nat n, Nat m, Ord x, Ring x) => Predicate (FromTo m n) x

#From Source

data From n

A 'Predicate' ensuring that the value is equal to or greater than a given int

Instances

(Nat n, Ord x, Ring x) => Predicate (From n) x

#EqualTo Source

data EqualTo n

A 'Predicate' ensuring that the value is equal to a given int

Instances

(Nat n, Eq x, Ring x) => Predicate (EqualTo n) x

#And Source

data And l r

A 'Predicate' ensuring that both given Predicates are valid

Instances

(Predicate l x, Predicate r x) => Predicate (And l r) x

#Predicate Source

class Predicate p x  where

Members

validate :: p -> x -> Either (RefinedError x) x

Instances

Predicate IdPred x
(Predicate l x, Predicate r x) => Predicate (And l r) x
(Predicate l x, Predicate r x) => Predicate (Or l r) x
(Predicate a x, Foldable t, Nat n) => Predicate (SizeEqualTo n) (t a)
(Predicate a x, Foldable t, Nat n) => Predicate (SizeGreaterThan n) (t a)
(Predicate a x, Foldable t, Nat n) => Predicate (SizeLessThan n) (t a)
(Predicate a x) => Predicate (Not a) x
(Nat n, Ord x, Ring x) => Predicate (LessThan n) x
(Nat n, Ord x, Ring x) => Predicate (GreaterThan n) x
(Nat n, Ord x, Ring x) => Predicate (From n) x
(Nat n, Ord x, Ring x) => Predicate (To n) x
(Nat n, Nat m, Ord x, Ring x) => Predicate (FromTo m n) x
(Nat n, Eq x, Ring x) => Predicate (EqualTo n) x
(Nat n, Eq x, Ring x) => Predicate (NotEqualTo n) x

Modules: Data.Refined; Data.Refined.Error; Data.Refined.Internal; Data.Refined.Predicate