PredicateTransformers

This library is based on the notion of a predicate transformer, the below type PT a b, which is a function from a to predicates on b. They act as a sort of compositional "matcher language". Composing these predicate transformers is meant to be analogous to composing optics and there are utilities for using predicate transformers with (lens-style) optics.

Some predicate transformers provided by other libraries: all, any (base) either (base) allOf (lens)

Documentation

type Pred a = a -> Bool

A convenient alias for predicates.

type PT a b = Pred a -> Pred b

Predicate transformers form a category where composition is ordinary function composition. Forms a category with . and id. Multiple are already provided by the standard library, for instance all and any.

match :: APrism s t a b -> PT a s

Operate on the target of a prism, or fail.

nay :: PT a a

Invert a predicate.

just :: PT a (Maybe a)

Operate on the Just branch of a Maybe, or fail.

left :: PT e (Either e a)

Operate on the Left branch of an Either, or fail.

right :: PT a (Either e a)

Operate on the Right branch of an Either, or fail.

endingWith :: Foldable f => PT a (f a)

Operate on the last value in a foldable, or fail if it's not present.

startingWith :: Foldable f => PT a (f a)

Operate on the first value in a foldable, or fail if it's not present.

only :: Foldable f => PT a (f a)

Require that a foldable has a single element, and operate on that element.

kth :: Foldable f => Int -> PT a (f a)

Only test the kth element of a foldable.

list :: [Pred a] -> Pred [a]

Given a list of predicates and a list of values, ensure that each predicate holds for each respective value. Fails if the two lists have different lengths.

dist :: (Eq (f ()), Functor f, Foldable f) => f (Pred a) -> Pred (f a)

Given a functor-full of predicates, and a functor-full of values, ensure that the structures of the two functors match and apply all of the predicates to all of the values. Generalized version of list.

distRep :: Representable f => f (a -> Bool) -> f a -> f Bool

Given a representable functor-full of predicates, and a functor-full of values, yield a representable functor-full of booleans. Similar to dist.

allTrue :: [Pred a] -> Pred a

Test all predicates against one value.

allOf1 :: Getting (All, Any) s a -> PT a s

Check that a predicate is true for all values behind a generalized getter and that there's at least one value for which it's true.

(==>) :: a -> b -> (a, b)

Sugar for tupling.

pair :: Pred a -> Pred b -> Pred (a, b)

(!) :: (b -> a) -> (a -> c) -> b -> c

Flipped function composition; f ! for a function f is a predicate transformer.

traced :: Show a => (a -> c) -> a -> c

Prints the input of a predicate, for debugging.

traceFail :: (a -> String) -> PT a a

Prints the input of a predicate, if the predicate fails.

traceFailShow :: Show a => PT a a

something :: Pred a

Predicate which always succeeds.

forced :: NFData a => a -> Bool

Predicate which triggers full evaluation of its input. Useful for testing that an exception isn't thrown.