úÎŽfˆc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abNone;The number of spaces to use for each level of indentation. @How many levels of indentation to use. Typically you will start D this at zero. It is incremented by one for each level as functions  descend through the tree. :An operand may return Just True or Just False to indicate > success or failure. It may also return Nothing to indicate a  discard. :Just False if the child is Just False; Nothing otherwise. 8Just True if the child is Just True; Nothing otherwise. AJust True is Just False and vice versa; Nothing remains Nothing. ;At least one of the Pdct in the list must be Just True. An 5 empty list or list with only Nothing is Just False. =None of the Pdct in list may be Just False. An empty list or & list with only Nothing is Just True. A tree of predicates. ARenames the top level of the Pdct. The function you pass will be  applied to the old name. @Given a function that un-boxes values of type b, changes a Node  from type a to type b. @Given a function that un-boxes values of type b, changes a Pdct  from type a to type b. BCreates a new operand. The Pdct is Just True or Just False, never  Nothing. <Turns an existing Pdct to one that never says False. If the C underlying predicate returns Just True, the new Pdct also returns 1 Just True. Otherwise, the Pdct returns Nothing. ;Turns an existing Pdct to one that never says True. If the D underlying predicate returns Just False, the new Pdct also returns 2 Just False. Otherwise, the Pdct returns Nothing. $Returns a tree that is always True. %Returns a tree that is always False. Forms a Pdct using . Forms a Pdct using . c-Indents text, and adds a newline to the end. )Shows a Pdct tree without evaluating it. Evaluates a Pdct. Verbosely evaluates a Pdct. " cd'Indent each level by this many spaces. 6If True, show discarded test results; otherwise, hide  them. The subject to evaluate <How many levels deep in the tree we are. Typically you will = start at level 0. This determines the level of indentation. efg       cdefgNone(BParses an RPN expression and returns the resulting Pdct. Fails if B there are no operands left on the stack or if there are multiple @ operands left on the stack; the stack must contain exactly one  operand in order to succeed.  !"#$%&'(  !"#$%&'( $!#" %&'( !#"$%&'(NonehValues on the operator stack. i+If the token is a binary operator A, then: DIf A is left associative, while there is an operator B of higher or @ equal precedence than A at the top of the stack, pop B off the $ stack and append it to the output. BIf A is right associative, while there is an operator B of higher D precedence than A at the top of the stack, pop B off the stack and  append it to the output. Push A onto the stack. ;If a token is an operand, append it to the postfix output. #And has higher precedence than Or. j>Pops operators from the operator stack and places then in the E output queue, as long as there is an And operator on the top of the  operator stack. k@Pops operators off the operator stack and onto the output stack 9 as long as the top of the operator stack is not an open E parenthesis. When an open parenthesis is encountered, pop that too, ? but not onto the output stack. Fails if the stack has no open  parentheses. lAPlaces an open parenthesis on the top of the operator stack. For B Close parenthesis, pops operators off the operator stack through 2 the next open parenthesis on the operator stack. /ACreates an RPN expression from an infix one. Fails only if there D are mismatched parentheses. It is possible to create a nonsensical 1 RPN expression; the RPN parser must catch this. m>Pops remaining items off operator stack. Fails if there is an < open paren left on the stack, as this indicates mismatched  parenthesis. hno)*+,-.pijkl/>The input tokens, with the beginning of the expression on the  left side of the sequence. 9The output sequence of tokens, with the beginning of the * expression on the left side of the list. m)*+,-./,.-)+*/ hon)+*,.-pijkl/mNone 0$Is this an infix or RPN expression? 44A single type for both RPN tokens and infix tokens. 5Creates Operands from Pdct. 6The And operator 7The Or operator 8The Not operator 9Open parentheses :Close parentheses ;>Parses expressions. Fails if the expression is nonsensical in B some way (for example, unbalanced parentheses, parentheses in an E RPN expression, or multiple stack values remaining.) Works by first ) changing infix expressions to RPN ones. 01234qr56789:s; 0123456789:; 0213456789:; 02134qr56789:s;None!<0How verbose to be when showing names of groups. =8Show all groups, and indicate which groups are skipped. >"Show groups that are not skipped. ?:Show no group names at all. However, groups will still be  indented. BATrue if the tree returned a result without completely evaluating * all parts of the tree. This can occur if M is True and & one of the tests in the tree failed. COptions for running tests. E&Indent each level by this many spaces F'Use this verbosity for tests that pass G'Use this verbosity for tests that fail H4Groups are run only if this predicate returns True. I3Tests are run only if this predicate returns True. J!Some tests might be skipped; see I. This controls ; whether you want to see a notification of tests that were / skipped. (Does not affect skipped groups; see K  for that.) K7Show group names? Even if you do not show the names of 8 groups, tests within the group will still be indented. LThe subjects to test M:If True, then tests will stop running immediately after a 8 single test fails. If False, all tests are always run. N@How verbose to be when reporting the results of tests. It would D be possible to have many more knobs to control this behavior; this > implementation is a compromise and hopefully provides enough / verbosity settings without being too complex. O8Shows discarded subjects. Cumulative, so also does what  Q and P do. Also shows all discarded $ evaluation steps for all subjects. P;Show subjects that are True. (This is cumulative, so False 0 subjects are shown too, as they would be using Q.) @ Shows all evaluation steps that led to the subject being True; 4 however, does not show discarded evaluation steps. Q@Show subjects that are False. In addition, shows all evaluation C steps that led to the subject being False; however, does not show A discarded evaluation steps. Does not show True subjects at all. R,Show only whether the test passed or failed SShow nothing at all TAA test is a function of this type. The function must make chunks 5 in a manner that respects the applicable verbosity. XA tree of tests. Z"The name of a test or of a group. \Creates groups of tests. ]Creates tests. t4Determines whether to show a subject, and shows it. u;Given a Verbosity and a Maybe Boolean indicating whether a C subject is True, False, or a discard, returns whether to show the ? subject and whether to show the discards contained within the  subject. ^!Passes if every subject is True. _(Passes if at least n subjects are True. `%Shows a tree, without evaluating it. a0Evaluates a tree. This function is the basis of b, which # is typically a bit easier to use. bBRuns each test in a list of tests (though each test might not run  if M3 is True.) Reports on how many passed and how many  failed. (if M* is True, the FailCount will never exceed  1.) 0<=>?@ABCDEFGHIJKLMNOPQRST'Use this verbosity for tests that pass 'Use this verbosity for tests that fail UVWXYZ[\]tuvw^_xy`a Most options ?The tree will indented by this many levels; typically you will  want to start this at 0. ;The first element of the tuple is True if the tree was not % fully evaluated. This can happen if M is True and @ one of the tests in the tree failed. The second element of the ? tuple is a list of Either; each element of the list will be a B Left if that component of the tree was not a test, or a Right if @ that element was a test. The Right will contain a tuple, where @ the first element indicates whether the test passed or failed, . and the second element is the list of Chunk. z{b|(<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab(ZTXYUWV]^_\NSRQPO<?>=A@b`CDEFGHIJKLMB[a<?>=@ABC DEFGHIJKLMNSRQPOTUWVXYZ[\]tuvw^_xy`az{b|}      !"#$%&'()*+,-./01234567)89:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWXYZZ[\]^_`abcdefghijklmnopq8rstuvwdxyz{|prednote-0.4.0.0Data.Prednote.PdctData.Prednote.Expressions.RPNData.Prednote.Expressions.InfixData.Prednote.ExpressionsData.Prednote.TestTree ShowDiscards IndentAmtLevelNodeOperand NeverTrue NeverFalseNotOrAndPdctLabelrenameboxNodeboxPdctandornotoperand neverFalse neverTruealwaysnever&&&|||showPdctevalevaluateOperatorOpNotOpOrOpAndRPNToken TokOperator TokOperandError pushOperand pushOperator pushTokenparseRPNParenCloseOpen InfixTokenTokParenTokRPN createRPNExprDescRPNInfixTokenopAndopOropNot openParen closeParenparseExpressionGroupVerbosity AllGroups ActiveGroupsNoGroups FailCount PassCount ShortCircuitTestOpts tIndentAmttPassVerbositytFailVerbosity tGroupPred tTestPredtShowSkippedTeststGroupVerbosity tSubjects tStopOnFail VerbosityDiscards TrueSubjects FalseSubjectsPassFailSilentTestFuncPayloadTestGroupTestTreeNamePassgrouptesteachSubjectMustBeTruenSubjectsMustBeTrue showTestTreeevalTreerunTestsindent labelBoolevalAndevalOr $fShowPdct OpStackValprocessRPNTokenpopperpopThroughOpen processParenpopRemainingOperators StkOpenParenStkOpprocessInfixTokenunToken toksToRPN showSubjectisSubjectAndDiscardsShown showTestTitleisTrueskip evalGroupevalTest unfoldList