Safe Haskell | Safe-Inferred |
---|---|

Language | Haskell2010 |

- newtype Pred a = Pred (a -> Result)
- predicate :: Show a => Text -> (a -> Bool) -> Pred a
- (&&&) :: Pred a -> Pred a -> Pred a
- (|||) :: Pred a -> Pred a -> Pred a
- not :: Pred a -> Pred a
- switch :: Pred a -> Pred b -> Pred (Either a b)
- any :: Pred a -> Pred [a]
- all :: Pred a -> Pred [a]
- data Nothing
- maybe :: Pred Nothing -> Pred a -> Pred (Maybe a)
- addLabel :: Text -> Pred a -> Pred a
- true :: Show a => Pred a
- false :: Show a => Pred a
- same :: Pred Bool
- test :: Pred a -> a -> Bool
- verboseTest :: Pred a -> a -> ([Chunk], Bool)
- verboseTestStdout :: Pred a -> a -> IO Bool
- newtype Condition = Condition [Chunk]
- newtype Value = Value Text
- newtype Label = Label Text
- data Labeled a = Labeled [Label] a
- data Passed
- data Failed
- newtype Result = Result (Labeled (Either Failed Passed))
- splitResult :: Result -> Either (Labeled Failed) (Labeled Passed)
- resultToChunks :: Result -> [Chunk]
- passedToChunks :: Int -> Labeled Passed -> [Chunk]
- failedToChunks :: Int -> Labeled Failed -> [Chunk]

# Predicates and their creation

Predicates. Is an instance of `Contravariant`

, which allows you
to change the type using `contramap`

. Though the constructor is
exported, ordinarily you shouldn't need to use it; other functions
in this module create `Pred`

and manipulate them as needed.

Contravariant Pred | |

Show (Pred a) |

predicate :: Show a => Text -> (a -> Bool) -> Pred a Source

Creates a new `Pred`

. In `predicate cond f`

, `cond`

describes
the condition, while `f`

gives the predicate function. For
example, if `f`

is `(> 5)`

, then `cond`

might be ```
"is greater than
5"
```

.

# Predicate combinators

## Primitive combinators

You might consider these combinators to be "primitive" in the
sense that you can build a `Pred`

for any user-defined type by
using these combinators alone, along with `contramap`

. Use
`&&&`

, `|||`

, and `contramap`

to analyze product types. Use `switch`

and `contramap`

to analyze sum types. For a simple example, see the
source code for `maybe`

, which is a simple sum type. For more
complicated examples, see the source code for `any`

and `all`

, as
a list is a sum type where one of the summands is a (recursive!)
product type.

## Convenience combinators

These were written using entirely the "primitive" combinators given above.

# Labeling

# Constant predicates

# Evaluating predicates

verboseTest :: Pred a -> a -> ([Chunk], Bool) Source

verboseTestStdout :: Pred a -> a -> IO Bool Source

Like `verboseTest`

, but results are printed to standard output.
Primarily for use in debugging or in a REPL.

# Results and converting them to `Chunk`

s

Usually you will not need these functions and types, as the functions and types above should meet most use cases; however, these are here so the test suites can use them, and in case you need them.

Gives additional information about a particular `Pred`

to aid the
user when viewing the output.

Any type that is accompanied by a set of labels.

The result of processing a `Pred`

.

splitResult :: Result -> Either (Labeled Failed) (Labeled Passed) Source

Returns whether this `Result`

failed or passed.

resultToChunks :: Result -> [Chunk] Source

Obtain a list of `Chunk`

describing the evaluation process.

Obtain a list of `Chunk`

describing the evaluation process.