Xe      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd Safe-Inferred-*Predicates that do not run in any context.Predicates. Is an instance of e-, which allows you to change the type using fx. Though the constructor is exported, ordinarily you shouldn't need to use it; other functions in this module create  and manipulate them as needed.The fU type variable is an arbitrary context; ordinarily this type will be an instance of g, and some of the bindings in this module require this. That allows you to run predicate computations that run in some sort of context, allowing you to perform IO, examine state, or whatever. If you only want to do pure computations, just use the  type synonym.The result of processing a .A  that returned hA  created with A  created with  A  created with  A  created with  A  that returned i A  created with  A  created with A  created with A  created with 0Any type that is accompanied by a set of labels.0Gives additional information about a particular * to aid the user when viewing the output.%Stores the representation of a value.,Describes the condition; for example, for a  j, this might be is greater than 5; for a  k, this might be begins with "Hello".Like f4 but allows the mapping function to run in a monad.Returns whether this  failed or passed. Runs pure  computations.Creates a new * that run in some arbitrary context. In predicateM cond f, cond describes the condition, while f1 gives the predicate function. For example, if f is (> 5), then cond might be "is greater than 5".Creates a new & that do not run in any context. In predicate cond f, cond describes the condition, while f1 gives the predicate function. For example, if f is (> 5), then cond might be "is greater than 5".And. Returns i if both argument  return iA. Is lazy in its second argment; if the first argument returns h, the second is ignored. Or. Returns i if either argument  returns iB. Is lazy in its second argument; if the first argument returns i", the second argument is ignored.Negation. Returns i if the argument  returns h. Uses the appropriate  depending on the l value. In ) (  l r) e, the resulting  returns the result of l if e is m or the result of r if e is n!. Is lazy, so the the argument  that is not used is ignored.o Did this  pass or fail?!Always returns i"Always returns h#Always returns its argument$Adds descriptive text to a J. Gives useful information for the user. The label is added to the top  in the tree; any existing labels are also retained. Labels that were added last will be printed first. For an example of this, see the source code for % and &.%Like p; is i if any of the list items are i. An empty list returns h5. Is lazy; will stop processing if it encounters a i item.&Like q; is i if none of the list items is h. An empty list returns i4. Is lazy; will stop processing if it encouters a h item.' Create a  for r.(Runs a  against a value.)Runs a $ against a value, without a context.sRuns a 5 against a particular value; also returns a list of t$ describing the steps of evaulation.+Obtain a list of t# describing the evaluation process.uA colorful label for i values.vA colorful label for h values.wAppend two lists of t9, with an intervening space if both lists are not empty.xAppend two lists of t6, with an intervening hyphen if both lists have text.,Obtain a list of t# describing the evaluation process.-Obtain a list of t# describing the evaluation process..Like *[, but results are printed to standard output. Primarily for use in debugging or in a REPL.E  o!"#$%&'What to return on y Analyzes z values{|}()s*+uvwx~,Number of levels of indentation-Number of levels of indentation./  !"#$%&'()*+,-./ %&'$!"#)(*.   +,-6    o!"#$%&'{|}()s*+uvwx~,-. Safe-Inferred93Parses an RPN expression and returns the resulting Pred. Fails if 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. /0123456789 /0123456789 354/2106789/2103546789 Safe-InferredValues on the operator stack.*If the token is a binary operator A, then:If 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.If A is right associative, while there is an operator B of higher 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.Pops operators from the operator stack and places then in the output queue, as long as there is an And operator on the top of the operator stack. Pops operators off the operator stack and onto the output stack as long as the top of the operator stack is not an open parenthesis. When an open parenthesis is encountered, pop that too, but not onto the output stack. Fails if the stack has no open parentheses.Places an open parenthesis on the top of the operator stack. For Close parenthesis, pops operators off the operator stack through the next open parenthesis on the operator stack.@Creates an RPN expression from an infix one. Fails only if there are mismatched parentheses. It is possible to create a nonsensical RPN expression; the RPN parser must catch this.Pops remaining items off operator stack. Fails if there is an open paren left on the stack, as this indicates mismatched parenthesis.:;<=>?@YThe input tokens, with the beginning of the expression on the left side of the sequence.bThe output sequence of tokens, with the beginning of the expression on the left side of the list.:;<=>?@=?>:<;@ :<;=?>@ Safe-Inferred A#Is this an infix or RPN expression?E3A single type for both RPN tokens and infix tokens.FCreates Operands from .GThe And operatorHThe Or operatorIThe Not operatorJOpen parenthesesKClose parenthesesLParses expressions. Fails if the expression is nonsensical in some way (for example, unbalanced parentheses, parentheses in an RPN expression, or multiple stack values remaining.) Works by first changing infix expressions to RPN ones.ABCDEFGHIJKL ABCDEFGHIJKL ACBDEFGHIJKL ACBDEFGHIJKL Safe-Inferred MgBuild a Pred that compares items. The idea is that the item on the right hand side is baked into the  and that the C compares this single right-hand side to each left-hand side item.NgBuild a Pred that compares items. The idea is that the item on the right hand side is baked into the  and that the C compares this single right-hand side to each left-hand side item.OOverloaded version of N.P Builds a  that tests items for equality.Q Builds a  that tests items for equality.ROverloaded version of Q.S Builds a 2 for items that might fail to return a comparison.T Builds a 2 for items that might fail to return a comparison.d,Parses a string that contains text, such as >=@, which indicates which comparer to use. Returns the comparer. Append two $, with an intervening space if both  are not empty.M"Description of the right-hand sideHow to compare the left-hand side to the right-hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.When subjects are compared, this ordering must be the result in order for the Predbox to be True; otherwise it is False. The subject will be on the left hand side.N"Description of the right-hand sideHow to compare the left-hand side to the right-hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.When subjects are compared, this ordering must be the result in order for the Predbox to be True; otherwise it is False. The subject will be on the left hand side.ORight-hand sideWhen subjects are compared, this ordering must be the result in order for the Predbox to be True; otherwise it is False. The subject will be on the left hand side.P"Description of the right-hand side=How to compare an item against the right hand side. Return i if the items are equal; h otherwise.Q"Description of the right-hand side=How to compare an item against the right hand side. Return i if the items are equal; h otherwise.RRight-hand sideS"Description of the right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.When subjects are compared, this ordering must be the result in order for the Predbox to be True; otherwise it is False. The subject will be on the left hand side.T"Description of the right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.When subjects are compared, this ordering must be the result in order for the Predbox to be True; otherwise it is False. The subject will be on the left hand side.URight-hand sideVRight-hand sideWRight-hand sideXRight-hand sideYRight-hand sideZDescription of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.[Description of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.\Description of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.]Description of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.^Description of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side._Description of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.`Description of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.aDescription of right-hand sideHow to compare an item against the right hand side. Return LT if the item is less than the right hand side; GT if greater; EQ if equal to the right hand side.bDescription of right-hand side=How to compare an item against the right hand side. Return i if equal; h otherwise.cDescription of right-hand side=How to compare an item against the right hand side. Return i if equal; h otherwise.d)The string with the comparer to be parsed3A function that, when given an ordering, returns a 9. Typically you will get this by partial application of O, N, or T.AIf an invalid comparer string is given, Nothing; otherwise, the .MNOPQRSTUVWXYZ[\]^_`abcdNOQRTUVWXY[]_acMPSZ\^`bdMNOPQRSTUVWXYZ[\]^_`abcd Safe-InferredS  !"#$%&'()*+,-.ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghfgijklmnomnpmnqjkrjstjsujsvwjx&jx'jyz{|}~jyjyFprednote-0.32.0.0 Prednote.CorePrednote.Expressions.RPNPrednote.Expressions.InfixPrednote.ExpressionsPrednote.ComparisonsPrednotePredPredMrunPredMResultFailedFNotFOrFAnd FTerminalPassedPNotPOrPAnd PTerminalLabeledLabelValue Condition contramapM splitResultrunPred predicateM predicate&&&|||notswitchtruefalsesameaddLabelanyallmaybetestMtest verboseTestresultToChunkspassedToChunksfailedToChunksverboseTestStdoutOperatorOpNotOpOrOpAndRPNToken TokOperator TokOperand pushOperand pushOperator pushTokenparseRPNParenCloseOpen InfixTokenTokParenTokRPN createRPNExprDescRPNInfixErrorTokenoperandopAndopOropNot openParen closeParenparseExpression compareByM compareBycompareequalByMequalByequalcompareByMaybeMcompareByMaybegreaterless greaterEqlessEqnotEq greaterByM greaterBylessByMlessBy greaterEqByM greaterEqBy lessEqByMlessEqBynotEqByMnotEqBy parseComparercontravariant-1.3Data.Functor.Contravariant Contravariant contramapbaseGHC.BaseMonadghc-prim GHC.TypesFalseTrueIntString Data.EitherEitherLeftRight resultToBoolGHC.List Data.MaybeMaybe verboseTestMrainbow-0.20.4.0 Rainbow.TypesChunklblTruelblFalse<+><->NothingJust explainAnd explainOr explainNothyphen chunksNull indentAmtspacesnewline labelToChunksexplainTerminal$fContravariantPredM $fShowPredM$fFunctorLabeled $fMonoidLabel $fMonoidValue$fMonoidCondition OpStackValprocessRPNTokenpopperpopThroughOpen processParenpopRemainingOperators StkOpenParenStkOpprocessInfixTokenunToken toksToRPN text-1.2.0.4Data.Text.InternalText