Data.Prednote.Pdct

Trees of predicates.

Exports names which conflict with Prelude names, so you probably want to import this module qualified.

The Pdct tree

type Label = Text

data Pdct a

A tree of predicates.

Constructors

Pdct Label (Node a)

Instances

Show (Pdct a)

data Node a

Constructors

And [Pdct a]

None of the Pdct in list may be Just False. An empty list or list with only Nothing is Just True.

Or [Pdct a]

At least one of the Pdct in the list must be Just True. An empty list or list with only Nothing is Just False.

Not (Pdct a)

Just True is Just False and vice versa; Nothing remains Nothing.

NeverFalse (Pdct a)

Just True if the child is Just True; Nothing otherwise.

NeverTrue (Pdct a)

Just False if the child is Just False; Nothing otherwise.

Operand (a -> Maybe Bool)

An operand may return Just True or Just False to indicate success or failure. It may also return Nothing to indicate a discard.

rename :: (Text -> Text) -> Pdct a -> Pdct a

Renames the top level of the Pdct. The function you pass will be applied to the old name.

always :: Pdct a

Returns a tree that is always True.

never :: Pdct a

Returns a tree that is always False.

Creating operands

operand :: Text -> (a -> Bool) -> Pdct a

Creates a new operand. The Pdct is Just True or Just False, never Nothing.

Creating Pdct from other Pdct

and :: [Pdct a] -> Pdct a

or :: [Pdct a] -> Pdct a

not :: Pdct a -> Pdct a

neverFalse :: Pdct a -> Pdct a

Turns an existing Pdct to one that never says False. If the underlying predicate returns Just True, the new Pdct also returns Just True. Otherwise, the Pdct returns Nothing.

neverTrue :: Pdct a -> Pdct a

Turns an existing Pdct to one that never says True. If the underlying predicate returns Just False, the new Pdct also returns Just False. Otherwise, the Pdct returns Nothing.

(&&&) :: Pdct a -> Pdct a -> Pdct a

Forms a Pdct using and.

(|||) :: Pdct a -> Pdct a -> Pdct a

Forms a Pdct using or.

boxPdct :: (b -> a) -> Pdct a -> Pdct b

Given a function that un-boxes values of type b, changes a Pdct from type a to type b.

boxNode :: (b -> a) -> Node a -> Node b

Given a function that un-boxes values of type b, changes a Node from type a to type b.

Showing and evaluating Pdct

type Level = Int

How many levels of indentation to use. Typically you will start this at zero. It is incremented by one for each level as functions descend through the tree.

type IndentAmt = Int

The number of spaces to use for each level of indentation.

type ShowDiscards = Bool

showPdct :: IndentAmt -> Level -> Pdct a -> [Chunk]

Shows a Pdct tree without evaluating it.

eval :: Pdct a -> a -> Maybe Bool

Evaluates a Pdct.

evaluate

Arguments

:: IndentAmt

Indent each level by this many spaces.

-> ShowDiscards

If True, show discarded test results; otherwise, hide them.

-> a

The subject to evaluate

-> Level

How many levels deep in the tree we are. Typically you will start at level 0. This determines the level of indentation.

-> Pdct a

-> (Maybe Bool, [Chunk])

Verbosely evaluates a Pdct.