Refined.Internal

In type theory, a refinement type is a type endowed with a predicate which is assumed to hold for any element of the refined type.

This library allows one to capture the idea of a refinement type using the Refined type. A Refined p x wraps a value of type x, ensuring that it satisfies a type-level predicate p.

A simple introduction to this library can be found here: http://nikita-volkov.github.io/refined/

Refined

newtype Refined p x

A refinement type, which wraps a value of type x, ensuring that it satisfies a type-level predicate p.

Constructors

Refined x

Instances

Foldable (Refined p)

Defined in Refined.Internal

Methods

fold :: Monoid m => Refined p m -> m

foldMap :: Monoid m => (a -> m) -> Refined p a -> m

foldr :: (a -> b -> b) -> b -> Refined p a -> b

foldr' :: (a -> b -> b) -> b -> Refined p a -> b

foldl :: (b -> a -> b) -> b -> Refined p a -> b

foldl' :: (b -> a -> b) -> b -> Refined p a -> b

foldr1 :: (a -> a -> a) -> Refined p a -> a

foldl1 :: (a -> a -> a) -> Refined p a -> a

toList :: Refined p a -> [a]

null :: Refined p a -> Bool

length :: Refined p a -> Int

elem :: Eq a => a -> Refined p a -> Bool

maximum :: Ord a => Refined p a -> a

minimum :: Ord a => Refined p a -> a

sum :: Num a => Refined p a -> a

product :: Num a => Refined p a -> a

Eq x => Eq (Refined p x)

Defined in Refined.Internal

Methods

(==) :: Refined p x -> Refined p x -> Bool

(/=) :: Refined p x -> Refined p x -> Bool

Ord x => Ord (Refined p x)

Defined in Refined.Internal

Methods

compare :: Refined p x -> Refined p x -> Ordering

(<) :: Refined p x -> Refined p x -> Bool

(<=) :: Refined p x -> Refined p x -> Bool

(>) :: Refined p x -> Refined p x -> Bool

(>=) :: Refined p x -> Refined p x -> Bool

max :: Refined p x -> Refined p x -> Refined p x

min :: Refined p x -> Refined p x -> Refined p x

(Read x, Predicate p x) => Read (Refined p x)

This instance makes sure to check the refinement.

Defined in Refined.Internal

Methods

readsPrec :: Int -> ReadS (Refined p x)

readList :: ReadS [Refined p x]

readPrec :: ReadPrec (Refined p x)

readListPrec :: ReadPrec [Refined p x]

Show x => Show (Refined p x)

Defined in Refined.Internal

Methods

showsPrec :: Int -> Refined p x -> ShowS

show :: Refined p x -> String

showList :: [Refined p x] -> ShowS

Lift x => Lift (Refined p x)

Defined in Refined.Internal

Methods

lift :: Refined p x -> Q Exp

(Arbitrary a, Predicate p a) => Arbitrary (Refined p a)

Defined in Refined.Orphan.QuickCheck

Methods

arbitrary :: Gen (Refined p a)

shrink :: Refined p a -> [Refined p a]

(ToJSON a, Predicate p a) => ToJSON (Refined p a)

Defined in Refined.Orphan.Aeson

Methods

toJSON :: Refined p a -> Value

toEncoding :: Refined p a -> Encoding

toJSONList :: [Refined p a] -> Value

toEncodingList :: [Refined p a] -> Encoding

(FromJSON a, Predicate p a) => FromJSON (Refined p a)

Defined in Refined.Orphan.Aeson

Methods

parseJSON :: Value -> Parser (Refined p a)

parseJSONList :: Value -> Parser [Refined p a]

Creation

refine :: Predicate p x => x -> Either RefineException (Refined p x)

A smart constructor of a Refined value. Checks the input value at runtime.

refineThrow :: (Predicate p x, MonadThrow m) => x -> m (Refined p x)

Constructs a Refined value at run-time, calling throwM if the value does not satisfy the predicate.

refineFail :: (Predicate p x, MonadFail m) => x -> m (Refined p x)

Constructs a Refined value at run-time, calling fail if the value does not satisfy the predicate.

refineError :: (Predicate p x, MonadError RefineException m) => x -> m (Refined p x)

Constructs a Refined value at run-time, calling throwError if the value does not satisfy the predicate.

refineTH :: (Predicate p x, Lift x) => x -> Q (TExp (Refined p x))

Constructs a Refined value at compile-time using -XTemplateHaskell.

For example:

>>> $$(refineTH 23) :: Refined Positive Int
Refined 23

Here's an example of an invalid value:

>>> $$(refineTH 0) :: Refined Positive Int
<interactive>:6:4:
    Value is not greater than 0
    In the Template Haskell splice $$(refineTH 0)
    In the expression: $$(refineTH 0) :: Refined Positive Int
    In an equation for ‘it’:
        it = $$(refineTH 0) :: Refined Positive Int

If it's not evident, the example above indicates a compile-time failure, which means that the checking was done at compile-time, thus introducing a zero runtime overhead compared to a plain value construction.

It may be useful to use this function with the `th-lift-instances` package at https://hackage.haskell.org/package/th-lift-instances/

Consumption

unrefine :: Refined p x -> x

Extracts the refined value.

Predicate

class Typeable p => Predicate p x where

A typeclass which defines a runtime interpretation of a type-level predicate p for type x.

Methods

validate :: Monad m => p -> x -> RefineT m ()

Check the value x according to the predicate p, producing an error string if the value does not satisfy.

Instances

Predicate IdPred x

Defined in Refined.Internal

Methods

validate :: Monad m => IdPred -> x -> RefineT m ()

(Foldable t, Ord a) => Predicate Descending (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => Descending -> t a -> RefineT m ()

(Foldable t, Ord a) => Predicate Ascending (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => Ascending -> t a -> RefineT m ()

(Eq x, Num x, KnownNat n) => Predicate (NotEqualTo n) x

Defined in Refined.Internal

Methods

validate :: Monad m => NotEqualTo n -> x -> RefineT m ()

(Eq x, Num x, KnownNat n) => Predicate (EqualTo n) x

Defined in Refined.Internal

Methods

validate :: Monad m => EqualTo n -> x -> RefineT m ()

(Ord x, Num x, KnownNat n) => Predicate (To n) x

Defined in Refined.Internal

Methods

validate :: Monad m => To n -> x -> RefineT m ()

(Ord x, Num x, KnownNat n) => Predicate (From n) x

Defined in Refined.Internal

Methods

validate :: Monad m => From n -> x -> RefineT m ()

(Ord x, Num x, KnownNat n) => Predicate (GreaterThan n) x

Defined in Refined.Internal

Methods

validate :: Monad m => GreaterThan n -> x -> RefineT m ()

(Ord x, Num x, KnownNat n) => Predicate (LessThan n) x

Defined in Refined.Internal

Methods

validate :: Monad m => LessThan n -> x -> RefineT m ()

(Predicate p x, Typeable p) => Predicate (Not p) x

Defined in Refined.Internal

Methods

validate :: Monad m => Not p -> x -> RefineT m ()

(Foldable t, KnownNat n) => Predicate (SizeEqualTo n) (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => SizeEqualTo n -> t a -> RefineT m ()

(Foldable t, KnownNat n) => Predicate (SizeGreaterThan n) (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => SizeGreaterThan n -> t a -> RefineT m ()

(Foldable t, KnownNat n) => Predicate (SizeLessThan n) (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => SizeLessThan n -> t a -> RefineT m ()

(Ord x, Num x, KnownNat n, KnownNat m, n <= m) => Predicate (NegativeFromTo n m) x

Defined in Refined.Internal

Methods

validate :: Monad m0 => NegativeFromTo n m -> x -> RefineT m0 ()

(Ord x, Num x, KnownNat mn, KnownNat mx, mn <= mx) => Predicate (FromTo mn mx) x

Defined in Refined.Internal

Methods

validate :: Monad m => FromTo mn mx -> x -> RefineT m ()

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

Defined in Refined.Internal

Methods

validate :: Monad m => Or l r -> x -> RefineT m ()

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

Defined in Refined.Internal

Methods

validate :: Monad m => And l r -> x -> RefineT m ()

Logical predicates

data Not p

The negation of a predicate.

Instances

Generic (Not p)

Defined in Refined.Internal

Associated Types

type Rep (Not p) :: Type -> Type

Methods

from :: Not p -> Rep (Not p) x

to :: Rep (Not p) x -> Not p

Generic1 Not

Defined in Refined.Internal

Associated Types

type Rep1 Not :: k -> Type

Methods

from1 :: Not a -> Rep1 Not a

to1 :: Rep1 Not a -> Not a

(Predicate p x, Typeable p) => Predicate (Not p) x

Defined in Refined.Internal

Methods

validate :: Monad m => Not p -> x -> RefineT m ()

type Rep (Not p)

Defined in Refined.Internal

type Rep (Not p) = D1 (MetaData "Not" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type Rep1 Not

Defined in Refined.Internal

type Rep1 Not = D1 (MetaData "Not" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data And l r

The conjunction of two predicates.

Instances

Generic1 (And l :: Type -> Type)

Defined in Refined.Internal

Associated Types

type Rep1 (And l) :: k -> Type

Methods

from1 :: And l a -> Rep1 (And l) a

to1 :: Rep1 (And l) a -> And l a

Generic (And l r)

Defined in Refined.Internal

Associated Types

type Rep (And l r) :: Type -> Type

Methods

from :: And l r -> Rep (And l r) x

to :: Rep (And l r) x -> And l r

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

Defined in Refined.Internal

Methods

validate :: Monad m => And l r -> x -> RefineT m ()

type Rep1 (And l :: Type -> Type)

Defined in Refined.Internal

type Rep1 (And l :: Type -> Type) = D1 (MetaData "And" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type Rep (And l r)

Defined in Refined.Internal

type Rep (And l r) = D1 (MetaData "And" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type (&&) = And infixr 3

The conjunction of two predicates.

data Or l r

The disjunction of two predicates.

Instances

Generic1 (Or l :: Type -> Type)

Defined in Refined.Internal

Associated Types

type Rep1 (Or l) :: k -> Type

Methods

from1 :: Or l a -> Rep1 (Or l) a

to1 :: Rep1 (Or l) a -> Or l a

Generic (Or l r)

Defined in Refined.Internal

Associated Types

type Rep (Or l r) :: Type -> Type

Methods

from :: Or l r -> Rep (Or l r) x

to :: Rep (Or l r) x -> Or l r

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

Defined in Refined.Internal

Methods

validate :: Monad m => Or l r -> x -> RefineT m ()

type Rep1 (Or l :: Type -> Type)

Defined in Refined.Internal

type Rep1 (Or l :: Type -> Type) = D1 (MetaData "Or" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type Rep (Or l r)

Defined in Refined.Internal

type Rep (Or l r) = D1 (MetaData "Or" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type (||) = Or infixr 2

The disjunction of two predicates.

Identity predicate

data IdPred

A predicate which is satisfied for all types.

Instances

Generic IdPred

Defined in Refined.Internal

Associated Types

type Rep IdPred :: Type -> Type

Methods

from :: IdPred -> Rep IdPred x

to :: Rep IdPred x -> IdPred

Predicate IdPred x

Defined in Refined.Internal

Methods

validate :: Monad m => IdPred -> x -> RefineT m ()

type Rep IdPred

Defined in Refined.Internal

type Rep IdPred = D1 (MetaData "IdPred" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

Numeric predicates

data LessThan (n :: Nat)

A Predicate ensuring that the value is less than the specified type-level number.

Instances

Generic (LessThan n)

Defined in Refined.Internal

Associated Types

type Rep (LessThan n) :: Type -> Type

Methods

from :: LessThan n -> Rep (LessThan n) x

to :: Rep (LessThan n) x -> LessThan n

(Ord x, Num x, KnownNat n) => Predicate (LessThan n) x

Defined in Refined.Internal

Methods

validate :: Monad m => LessThan n -> x -> RefineT m ()

n <= m => Weaken (LessThan n) (To m)

Defined in Refined.Internal

Methods

weaken :: Refined (LessThan n) x -> Refined (To m) x

n <= m => Weaken (LessThan n) (LessThan m)

Defined in Refined.Internal

Methods

weaken :: Refined (LessThan n) x -> Refined (LessThan m) x

type Rep (LessThan n)

Defined in Refined.Internal

type Rep (LessThan n) = D1 (MetaData "LessThan" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data GreaterThan (n :: Nat)

A Predicate ensuring that the value is greater than the specified type-level number.

Instances

Generic (GreaterThan n)

Defined in Refined.Internal

Associated Types

type Rep (GreaterThan n) :: Type -> Type

Methods

from :: GreaterThan n -> Rep (GreaterThan n) x

to :: Rep (GreaterThan n) x -> GreaterThan n

(Ord x, Num x, KnownNat n) => Predicate (GreaterThan n) x

Defined in Refined.Internal

Methods

validate :: Monad m => GreaterThan n -> x -> RefineT m ()

m <= n => Weaken (GreaterThan n) (From m)

Defined in Refined.Internal

Methods

weaken :: Refined (GreaterThan n) x -> Refined (From m) x

m <= n => Weaken (GreaterThan n) (GreaterThan m)

Defined in Refined.Internal

Methods

weaken :: Refined (GreaterThan n) x -> Refined (GreaterThan m) x

type Rep (GreaterThan n)

Defined in Refined.Internal

type Rep (GreaterThan n) = D1 (MetaData "GreaterThan" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data From (n :: Nat)

A Predicate ensuring that the value is greater than or equal to the specified type-level number.

Instances

Generic (From n)

Defined in Refined.Internal

Associated Types

type Rep (From n) :: Type -> Type

Methods

from :: From n -> Rep (From n) x

to :: Rep (From n) x -> From n

(Ord x, Num x, KnownNat n) => Predicate (From n) x

Defined in Refined.Internal

Methods

validate :: Monad m => From n -> x -> RefineT m ()

m <= n => Weaken (From n) (From m)

Defined in Refined.Internal

Methods

weaken :: Refined (From n) x -> Refined (From m) x

m <= n => Weaken (GreaterThan n) (From m)

Defined in Refined.Internal

Methods

weaken :: Refined (GreaterThan n) x -> Refined (From m) x

p <= n => Weaken (FromTo n m) (From p)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (From p) x

type Rep (From n)

Defined in Refined.Internal

type Rep (From n) = D1 (MetaData "From" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data To (n :: Nat)

A Predicate ensuring that the value is less than or equal to the specified type-level number.

Instances

Generic (To n)

Defined in Refined.Internal

Associated Types

type Rep (To n) :: Type -> Type

Methods

from :: To n -> Rep (To n) x

to :: Rep (To n) x -> To n

(Ord x, Num x, KnownNat n) => Predicate (To n) x

Defined in Refined.Internal

Methods

validate :: Monad m => To n -> x -> RefineT m ()

n <= m => Weaken (To n) (To m)

Defined in Refined.Internal

Methods

weaken :: Refined (To n) x -> Refined (To m) x

n <= m => Weaken (LessThan n) (To m)

Defined in Refined.Internal

Methods

weaken :: Refined (LessThan n) x -> Refined (To m) x

m <= q => Weaken (FromTo n m) (To q)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (To q) x

type Rep (To n)

Defined in Refined.Internal

type Rep (To n) = D1 (MetaData "To" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data FromTo (mn :: Nat) (mx :: Nat)

A Predicate ensuring that the value is within an inclusive range.

Instances

Generic (FromTo mn mx)

Defined in Refined.Internal

Associated Types

type Rep (FromTo mn mx) :: Type -> Type

Methods

from :: FromTo mn mx -> Rep (FromTo mn mx) x

to :: Rep (FromTo mn mx) x -> FromTo mn mx

(Ord x, Num x, KnownNat mn, KnownNat mx, mn <= mx) => Predicate (FromTo mn mx) x

Defined in Refined.Internal

Methods

validate :: Monad m => FromTo mn mx -> x -> RefineT m ()

m <= q => Weaken (FromTo n m) (To q)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (To q) x

p <= n => Weaken (FromTo n m) (From p)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (From p) x

(p <= n, m <= q) => Weaken (FromTo n m) (FromTo p q)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (FromTo p q) x

type Rep (FromTo mn mx)

Defined in Refined.Internal

type Rep (FromTo mn mx) = D1 (MetaData "FromTo" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data EqualTo (n :: Nat)

A Predicate ensuring that the value is equal to the specified type-level number n.

Instances

Generic (EqualTo n)

Defined in Refined.Internal

Associated Types

type Rep (EqualTo n) :: Type -> Type

Methods

from :: EqualTo n -> Rep (EqualTo n) x

to :: Rep (EqualTo n) x -> EqualTo n

(Eq x, Num x, KnownNat n) => Predicate (EqualTo n) x

Defined in Refined.Internal

Methods

validate :: Monad m => EqualTo n -> x -> RefineT m ()

type Rep (EqualTo n)

Defined in Refined.Internal

type Rep (EqualTo n) = D1 (MetaData "EqualTo" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data NotEqualTo (n :: Nat)

A Predicate ensuring that the value is not equal to the specified type-level number n.

Instances

Generic (NotEqualTo n)

Defined in Refined.Internal

Associated Types

type Rep (NotEqualTo n) :: Type -> Type

Methods

from :: NotEqualTo n -> Rep (NotEqualTo n) x

to :: Rep (NotEqualTo n) x -> NotEqualTo n

(Eq x, Num x, KnownNat n) => Predicate (NotEqualTo n) x

Defined in Refined.Internal

Methods

validate :: Monad m => NotEqualTo n -> x -> RefineT m ()

type Rep (NotEqualTo n)

Defined in Refined.Internal

type Rep (NotEqualTo n) = D1 (MetaData "NotEqualTo" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type Positive = GreaterThan 0

A Predicate ensuring that the value is greater than zero.

type NonPositive = To 0

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

type Negative = LessThan 0

A Predicate ensuring that the value is less than zero.

type NonNegative = From 0

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

type ZeroToOne = FromTo 0 1

An inclusive range of values from zero to one.

type NonZero = NotEqualTo 0

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

data NegativeFromTo (n :: Nat) (m :: Nat)

A Predicate ensuring that the value is greater or equal than a negative number specified as a type-level (positive) number n and less than a type-level (positive) number m.

Instances

Generic (NegativeFromTo n m)

Defined in Refined.Internal

Associated Types

type Rep (NegativeFromTo n m) :: Type -> Type

Methods

from :: NegativeFromTo n m -> Rep (NegativeFromTo n m) x

to :: Rep (NegativeFromTo n m) x -> NegativeFromTo n m

(Ord x, Num x, KnownNat n, KnownNat m, n <= m) => Predicate (NegativeFromTo n m) x

Defined in Refined.Internal

Methods

validate :: Monad m0 => NegativeFromTo n m -> x -> RefineT m0 ()

type Rep (NegativeFromTo n m)

Defined in Refined.Internal

type Rep (NegativeFromTo n m) = D1 (MetaData "NegativeFromTo" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

Foldable predicates

data SizeLessThan (n :: Nat)

A Predicate ensuring that the Foldable has a length which is less than the specified type-level number.

Instances

Generic (SizeLessThan n)

Defined in Refined.Internal

Associated Types

type Rep (SizeLessThan n) :: Type -> Type

Methods

from :: SizeLessThan n -> Rep (SizeLessThan n) x

to :: Rep (SizeLessThan n) x -> SizeLessThan n

(Foldable t, KnownNat n) => Predicate (SizeLessThan n) (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => SizeLessThan n -> t a -> RefineT m ()

type Rep (SizeLessThan n)

Defined in Refined.Internal

type Rep (SizeLessThan n) = D1 (MetaData "SizeLessThan" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data SizeGreaterThan (n :: Nat)

A Predicate ensuring that the Foldable has a length which is greater than the specified type-level number.

Instances

Generic (SizeGreaterThan n)

Defined in Refined.Internal

Associated Types

type Rep (SizeGreaterThan n) :: Type -> Type

Methods

from :: SizeGreaterThan n -> Rep (SizeGreaterThan n) x

to :: Rep (SizeGreaterThan n) x -> SizeGreaterThan n

(Foldable t, KnownNat n) => Predicate (SizeGreaterThan n) (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => SizeGreaterThan n -> t a -> RefineT m ()

type Rep (SizeGreaterThan n)

Defined in Refined.Internal

type Rep (SizeGreaterThan n) = D1 (MetaData "SizeGreaterThan" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data SizeEqualTo (n :: Nat)

A Predicate ensuring that the Foldable has a length which is equal to the specified type-level number.

Instances

Generic (SizeEqualTo n)

Defined in Refined.Internal

Associated Types

type Rep (SizeEqualTo n) :: Type -> Type

Methods

from :: SizeEqualTo n -> Rep (SizeEqualTo n) x

to :: Rep (SizeEqualTo n) x -> SizeEqualTo n

(Foldable t, KnownNat n) => Predicate (SizeEqualTo n) (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => SizeEqualTo n -> t a -> RefineT m ()

type Rep (SizeEqualTo n)

Defined in Refined.Internal

type Rep (SizeEqualTo n) = D1 (MetaData "SizeEqualTo" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

type NonEmpty = SizeGreaterThan 0

A Predicate ensuring that the Foldable is non-empty.

IsList predicates

data Ascending

A Predicate ensuring that the Foldable contains elements in a strictly ascending order.

Instances

Generic Ascending

Defined in Refined.Internal

Associated Types

type Rep Ascending :: Type -> Type

Methods

from :: Ascending -> Rep Ascending x

to :: Rep Ascending x -> Ascending

(Foldable t, Ord a) => Predicate Ascending (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => Ascending -> t a -> RefineT m ()

type Rep Ascending

Defined in Refined.Internal

type Rep Ascending = D1 (MetaData "Ascending" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

data Descending

A Predicate ensuring that the Foldable contains elements in a strictly descending order.

Instances

Generic Descending

Defined in Refined.Internal

Associated Types

type Rep Descending :: Type -> Type

Methods

from :: Descending -> Rep Descending x

to :: Rep Descending x -> Descending

(Foldable t, Ord a) => Predicate Descending (t a)

Defined in Refined.Internal

Methods

validate :: Monad m => Descending -> t a -> RefineT m ()

type Rep Descending

Defined in Refined.Internal

type Rep Descending = D1 (MetaData "Descending" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) (V1 :: Type -> Type)

Weakening

class Weaken from to where

A typeclass containing "safe" conversions between refined predicates where the target is weaker than the source: that is, all values that satisfy the first predicate will be guarunteed to satisy the second.

Take care: writing an instance declaration for your custom predicates is the same as an assertion that weaken is safe to use:

instance Weaken Pred1 Pred2

For most of the instances, explicit type annotations for the result value's type might be required.

Minimal complete definition

Nothing

Methods

weaken :: Refined from x -> Refined to x

Instances

n <= m => Weaken (To n) (To m)

Defined in Refined.Internal

Methods

weaken :: Refined (To n) x -> Refined (To m) x

m <= n => Weaken (From n) (From m)

Defined in Refined.Internal

Methods

weaken :: Refined (From n) x -> Refined (From m) x

m <= n => Weaken (GreaterThan n) (From m)

Defined in Refined.Internal

Methods

weaken :: Refined (GreaterThan n) x -> Refined (From m) x

m <= n => Weaken (GreaterThan n) (GreaterThan m)

Defined in Refined.Internal

Methods

weaken :: Refined (GreaterThan n) x -> Refined (GreaterThan m) x

n <= m => Weaken (LessThan n) (To m)

Defined in Refined.Internal

Methods

weaken :: Refined (LessThan n) x -> Refined (To m) x

n <= m => Weaken (LessThan n) (LessThan m)

Defined in Refined.Internal

Methods

weaken :: Refined (LessThan n) x -> Refined (LessThan m) x

m <= q => Weaken (FromTo n m) (To q)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (To q) x

p <= n => Weaken (FromTo n m) (From p)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (From p) x

(p <= n, m <= q) => Weaken (FromTo n m) (FromTo p q)

Defined in Refined.Internal

Methods

weaken :: Refined (FromTo n m) x -> Refined (FromTo p q) x

andLeft :: Refined (And l r) x -> Refined l x

This function helps type inference. It is equivalent to the following:

instance Weaken (And l r) l

andRight :: Refined (And l r) x -> Refined r x

This function helps type inference. It is equivalent to the following:

instance Weaken (And l r) r

leftOr :: Refined l x -> Refined (Or l r) x

This function helps type inference. It is equivalent to the following:

instance Weaken l (Or l r)

rightOr :: Refined r x -> Refined (Or l r) x

This function helps type inference. It is equivalent to the following:

instance Weaken r (Or l r)

Error handling

RefineException

data RefineException

An exception encoding the way in which a Predicate failed.

Constructors

RefineNotException !TypeRep !RefineException

A RefineException for failures involving the Not predicate.

RefineAndException !TypeRep !(These RefineException RefineException)

A RefineException for failures involving the And predicate.

RefineOrException !TypeRep !RefineException !RefineException

A RefineException for failures involving the Or predicate.

RefineOtherException !TypeRep !(Doc Void)

A RefineException for failures involving all other predicates.

Instances

Show RefineException

Defined in Refined.Internal

Methods

showsPrec :: Int -> RefineException -> ShowS

show :: RefineException -> String

showList :: [RefineException] -> ShowS

Generic RefineException

Defined in Refined.Internal

Associated Types

type Rep RefineException :: Type -> Type

Methods

from :: RefineException -> Rep RefineException x

to :: Rep RefineException x -> RefineException

Exception RefineException

Encode a RefineException for use with Control.Exception.

Defined in Refined.Internal

Methods

toException :: RefineException -> SomeException

fromException :: SomeException -> Maybe RefineException

displayException :: RefineException -> String

Pretty RefineException

Pretty-print a RefineException.

Defined in Refined.Internal

Methods

pretty :: RefineException -> Doc ann

prettyList :: [RefineException] -> Doc ann

Monad m => MonadError RefineException (RefineT m)

Defined in Refined.Internal

Methods

throwError :: RefineException -> RefineT m a

catchError :: RefineT m a -> (RefineException -> RefineT m a) -> RefineT m a

type Rep RefineException

Defined in Refined.Internal

type Rep RefineException = D1 (MetaData "RefineException" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" False) ((C1 (MetaCons "RefineNotException" PrefixI True) (S1 (MetaSel (Just "_RefineException_typeRep") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 TypeRep) :*: S1 (MetaSel (Just "_RefineException_notChild") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 RefineException)) :+: C1 (MetaCons "RefineAndException" PrefixI True) (S1 (MetaSel (Just "_RefineException_typeRep") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 TypeRep) :*: S1 (MetaSel (Just "_RefineException_andChild") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (These RefineException RefineException)))) :+: (C1 (MetaCons "RefineOrException" PrefixI True) (S1 (MetaSel (Just "_RefineException_typeRep") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 TypeRep) :*: (S1 (MetaSel (Just "_RefineException_orLChild") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 RefineException) :*: S1 (MetaSel (Just "_RefineException_orRChild") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 RefineException))) :+: C1 (MetaCons "RefineOtherException" PrefixI True) (S1 (MetaSel (Just "_RefineException_typeRep") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 TypeRep) :*: S1 (MetaSel (Just "_RefineException_message") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Doc Void)))))

displayRefineException :: RefineException -> Doc ann

Display a RefineException as a Doc ann

RefineT and RefineM

data RefineT m a

A monad transformer that adds RefineExceptions to other monads.

The pure and return functions yield computations that produce the given value, while >>= sequences two subcomputations, exiting on the first RefineException.

Instances

MonadTrans RefineT

Defined in Refined.Internal

Methods

lift :: Monad m => m a -> RefineT m a

Monad m => MonadError RefineException (RefineT m)

Defined in Refined.Internal

Methods

throwError :: RefineException -> RefineT m a

catchError :: RefineT m a -> (RefineException -> RefineT m a) -> RefineT m a

Monad m => Monad (RefineT m)

Defined in Refined.Internal

Methods

(>>=) :: RefineT m a -> (a -> RefineT m b) -> RefineT m b

(>>) :: RefineT m a -> RefineT m b -> RefineT m b

return :: a -> RefineT m a

fail :: String -> RefineT m a

Functor m => Functor (RefineT m)

Defined in Refined.Internal

Methods

fmap :: (a -> b) -> RefineT m a -> RefineT m b

(<$) :: a -> RefineT m b -> RefineT m a

MonadFix m => MonadFix (RefineT m)

Defined in Refined.Internal

Methods

mfix :: (a -> RefineT m a) -> RefineT m a

Monad m => Applicative (RefineT m)

Defined in Refined.Internal

Methods

pure :: a -> RefineT m a

(<*>) :: RefineT m (a -> b) -> RefineT m a -> RefineT m b

liftA2 :: (a -> b -> c) -> RefineT m a -> RefineT m b -> RefineT m c

(*>) :: RefineT m a -> RefineT m b -> RefineT m b

(<*) :: RefineT m a -> RefineT m b -> RefineT m a

Generic1 (RefineT m :: Type -> Type)

Defined in Refined.Internal

Associated Types

type Rep1 (RefineT m) :: k -> Type

Methods

from1 :: RefineT m a -> Rep1 (RefineT m) a

to1 :: Rep1 (RefineT m) a -> RefineT m a

Generic (RefineT m a)

Defined in Refined.Internal

Associated Types

type Rep (RefineT m a) :: Type -> Type

Methods

from :: RefineT m a -> Rep (RefineT m a) x

to :: Rep (RefineT m a) x -> RefineT m a

type Rep1 (RefineT m :: Type -> Type)

Defined in Refined.Internal

type Rep1 (RefineT m :: Type -> Type) = D1 (MetaData "RefineT" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" True) (C1 (MetaCons "RefineT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (ExceptT RefineException m))))

type Rep (RefineT m a)

Defined in Refined.Internal

type Rep (RefineT m a) = D1 (MetaData "RefineT" "Refined.Internal" "refined-0.4-1Ly2nnRfmnJ9IeL6JEZ6Q" True) (C1 (MetaCons "RefineT" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ExceptT RefineException m a))))

runRefineT :: RefineT m a -> m (Either RefineException a)

The inverse of RefineT.

mapRefineT :: (m (Either RefineException a) -> n (Either RefineException b)) -> RefineT m a -> RefineT n b

Map the unwrapped computation using the given function.

runRefineT (mapRefineT f m) = f (runRefineT m)

type RefineM a = RefineT Identity a

RefineM a is equivalent to RefineT Identity a for any type a.

refineM :: Either RefineException a -> RefineM a

Constructs a computation in the RefineM monad. (The inverse of runRefineM).

runRefineM :: RefineM a -> Either RefineException a

Run a monadic action of type RefineM a, yielding an Either RefineException a.

This is just defined as runIdentity . runRefineT.

throwRefine :: Monad m => RefineException -> RefineT m a

One can use throwRefine inside of a monadic context to begin processing a RefineException.

catchRefine :: Monad m => RefineT m a -> (RefineException -> RefineT m a) -> RefineT m a

A handler function to handle previous RefineExceptions and return to normal execution. A common idiom is:

 do { action1; action2; action3 } `catchRefine' handler

where the action functions can call throwRefine. Note that handler and the do-block must have the same return type.

throwRefineOtherException

Arguments

:: Monad m

=> TypeRep

The TypeRep of the Predicate. This can usually be given by using typeOf.

-> Doc Void

A Doc Void encoding a custom error message to be pretty-printed.

-> RefineT m a

A handler for a RefineException.

throwRefineOtherException is useful for defining what behaviour validate should have in the event of a predicate failure.

(|>) :: a -> (a -> b) -> b infixl 0

Helper function, stolen from the flow package.

(.>) :: (a -> b) -> (b -> c) -> a -> c infixl 9

Helper function, stolen from the flow package.

Re-Exports

pretty :: Pretty a => a -> Doc ann

>>> pretty 1 <+> pretty "hello" <+> pretty 1.234
1 hello 1.234