47l      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk Safe-Inferred!Is this result visible? If not,   will not show it. The result of evaluating a  . Results that are not  are not shown by the   function. <Indicates whether there was a short circuit when evaluating  this  #. A short circuit occurs when the   does not : need to evaluate all of its children in order to reach a  result. If l), there was no short circuit; otherwise,  this is a m with a   providing a way to display  the short circuit. &The dynamic label; this indicates how  will show the   * to the user after it has been evaluated. A rose tree of predicates. 5A tree of static names, allowing you to identify the   # without applying it to a subject.  Evaluates a   by applying it to a subject. ?Indicates how to display text. This function is applied to an  n9 that is the level of indentation; each level of descent  through a tree of   increments this n by one. Because the  function returns a list of o, you can use multiple colors. > Typically this function will indent text accordingly, with a  newline at the end.  Shown by    Hidden by   No   in the list may be p for q to be r. An  empty list of   yields a   that always returns r.  May short circuit.  At least one   in the list must be r for the resulting    to be r. An empty list of   yields a   that  always returns p. May short circuit. Negates the child  . Never short circuits. Fanout. May short circuit. Fanout all. The resulting   is r if no child item  returns p'; an empty list of child items returns r. May  short circuit. Fanout any. The resulting   is r if at least one child  item returns r'; an empty list of child items returns p.  May short circuit.  Fanout at least. The resulting   is r if at least the $ given number of child items return r. May short circuit. (Indents and formats output for display. :Indents and formats static labels for display. This is a   for how the   would be applied.  Applies a  % to a single subject and returns the . Like # but also returns the accompanying . Like s. Like  but also returns a list of  , with one   for each list item.  shorter x y2 is True if list x is shorter than list y. Lazier @ than taking the length of each list and comparing the results. ! *This function is applied to a list of the  from  evaluating the child  $ on each fanout item. The function  must return a triple, with the t indicating success or  failure,  for visibility, and u n to indicate 0 whether a short circuit occurred; this must be l if there  was no short circuit, or m with an n to indicate a short  circuit, with the n* indicating that a short circuit occurred / after examining the given number of elements. The resulting  ' always short circuits if the previous  function returns a m n with the n being less than ! zero. Otherwise, the resulting   short circuits if  the n5 is less than the number of elements returned by the  fanout function. Fanout function Fanout function Fanout function ?Find at least this many. If this number is less than or equal  to zero,  will always return r. Fanout function $Start at this level of indentation. $Start at this level of indentation. vwx    vwx Safe-Inferred A colorful label for r values. A colorful label for p values. Indent amount. !Prefixes the given y with colorful text to indicate r  or p as appropriate. "Indents the given list of o by the given n multipled by   . Appends a newline. #A label for a short circuit. $ Indents a y by the given n multiplied by   . % Append two y$, with an intervening space if both y are  not empty. & Create a new   with a different static label. 'Creates a new  + with a result differing from the original   . (Creates a new  ! with a different dynamic label. )Creates a new  + with any short circuits having a colorful  label.  !"#$%&'Function to modify the   Modify the  of this   (:New dynamic label. Do not indicate whether the result is  r or p; this is done for you. )  !"#$%&'()  !"#$%&'()  !"#$%&'() Safe-Inferred*Builds predicates. +Always returns r and is always visible. ,Always returns p and is always visible. -.Returns the subject as is; is always visible. .Makes an existing   the child of a new   . The new  Pred has the same  as the child   . The new   - is always visible and never short circuits. / Creates a   with its visibility modified. 0 Creates a   that is always shown. 1 Creates a   that is always hidden. 2 Creates a   that is shown only if its  is  r. 3 Creates a   that is shown only if its  is  p. 4 No child Pred may be p. An empty list of child Pred  returns r. Always visible. 5Creates 4 Pred that are always visible. 6At least one child Pred must be r. An empty list of child  Pred returns p. Always visible. 7Creates 6 Pred that are always visible. 8Negation. Always visible. 9No fanned-out item may be p . An empty list of child items  returns r. :%At least one fanned-out item must be r. An empty list of  child items returns p. ;1At least the given number of child items must be r. * Static label @Computes the dynamic label. Do not indicate whether the result  is r or p&; this is automatically done for you. Predicate function +,-. Static label @Computes the dynamic label. Do not indicate whether the result  is r or p&; this is automatically done for you. /When applied to the  of the  , this function ! returns the desired visibility. 0123456789:;*+,-./0123456789:;*+,-./0123456789:;*+,-./0123456789:; Safe-Inferred<@Build a Pred that compares items. The idea is that the item on ' the right hand side is baked into the Pred and that the Pred C compares this single right-hand side to each left-hand side item. =Overloaded version of <. > Builds a Pred that tests items for equality. ?Overloaded version of >. @ Builds a Pred3 for items that might fail to return a comparison. K,Parses a string that contains text, such as >=, which indicates / which comparer to use. Returns the comparer. <7Description of the type of thing that is being matched #Description of the right-hand side Describes the left-hand side :How 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 F order for the Predbox to be True; otherwise it is False. The subject  will be on the left hand side. =7Description of the type of thing that is being matched Right-hand side @When subjects are compared, this ordering must be the result in F order for the Predbox to be True; otherwise it is False. The subject  will be on the left hand side. >7Description of the type of thing that is being matched #Description of the right-hand side Describes the left-hand side <How to compare an item against the right hand side. Return  r if the items are equal; p otherwise. ?7Description of the type of thing that is being matched Right-hand side @7Description of the type of thing that is being matched #Description of the right-hand side Describes the left-hand side AHow to compare an item against the right hand side. Return LT if A 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 F order for the Predbox to be True; otherwise it is False. The subject  will be on the left hand side. A/Description of the type of thing being matched Right-hand side B/Description of the type of thing being matched Right-hand side C/Description of the type of thing being matched Right-hand side D/Description of the type of thing being matched Right-hand side E/Description of the type of thing being matched Right-hand side F/Description of the type of thing being matched Description of right-hand side Describes the left-hand side >How to compare an item against the right hand side. Return LT A if the item is less than the right hand side; GT if greater; EQ " if equal to the right hand side. G/Description of the type of thing being matched Description of right-hand side Describes the left-hand side >How to compare an item against the right hand side. Return LT A if the item is less than the right hand side; GT if greater; EQ " if equal to the right hand side. H/Description of the type of thing being matched Description of right-hand side Describes the left-hand side >How to compare an item against the right hand side. Return LT A if the item is less than the right hand side; GT if greater; EQ " if equal to the right hand side. I/Description of the type of thing being matched Description of right-hand side Describes the left-hand side >How to compare an item against the right hand side. Return LT A if the item is less than the right hand side; GT if greater; EQ " if equal to the right hand side. J/Description of the type of thing being matched Description of right-hand side Describes the left-hand side <How to compare an item against the right hand side. Return  r if equal; p otherwise. K*The string with the comparer to be parsed 3A function that, when given an ordering, returns a  . 7 Typically you will get this by partial application of =,  <, or @. @If an invalid comparer string is given, Nothing; otherwise, the   . <=>?@ABCDEFGHIJK<=>?@ABCDEFGHIJK<=>?@ABCDEFGHIJK Safe-InferredVEParses an RPN expression and returns the resulting Predbox. 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. LMNOPQRSTUVz LMNOPQRSTUV PRQLONMSTUVLONMPRQSTUVz Safe-Inferred{Values on the operator stack. |+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. }>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. ~@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. APlaces 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. >Pops remaining items off operator stack. Fails if there is an < open paren left on the stack, as this indicates mismatched  parenthesis. {WXYZ[\|}~]>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. WXYZ[\]Z\[WYX] {WYXZ\[|}~] Safe-Inferred ^$Is this an infix or RPN expression? b4A single type for both RPN tokens and infix tokens. cCreates Operands from Predbox. dThe And operator eThe Or operator fThe Not operator gOpen parentheses hClose parentheses i>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. ^_`abcdefghi ^_`abcdefghi ^`_abcdefghi ^`_abcdefghi Safe-Inferredj:Indents and formats static labels for display. This is a j  for how the   would be applied. k(Indents and formats output for display. jk *+,-./0123456789:;jk /0123*+,-45678.9:;j kjk        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi jkljkmnopqrsnotjunovju!nowjkxyz{|}~bprednote-0.26.0.2 Prednote.CorePrednote.FormatPrednote.PrebuiltPrednote.ComparisonsPrednote.Expressions.RPNPrednote.Expressions.InfixPrednote.ExpressionsPrednotereportVisible unVisibleOutputresultvisibleshortdynamicPredstaticevaluateChunkershownhiddenallanynotfanfanAllfanAny fanAtLeastplantesttestVfilterfilterVshorterlblTruelblFalse indentAmtlblLineindentshortCir indentTxt<+>rename changeOutputspeak speakShort predicatetruefalsesamewrap visibilityrevealhideshowTrue showFalse&&&||| compareBycompareequalByequalcompareByMaybegreaterless greaterEqlessEqnotEq greaterBylessBy greaterEqBylessEqBynotEqBy parseComparerOperatorOpNotOpOrOpAndRPNToken TokOperator TokOperand pushOperand pushOperator pushTokenparseRPNParenCloseOpen InfixTokenTokParenTokRPN createRPNExprDescRPNInfixErrorTokenoperandopAndopOropNot openParen closeParenparseExpressionbase Data.MaybeNothingJustghc-prim GHC.TypesIntrainbow-0.18.0.0 Rainbow.TypesChunkFalseGHC.ListTrueBoolMaybe $fShowPred $fShowOutput$fContravariantPred text-1.1.1.3Data.Text.InternalText$fContravariantRPNToken OpStackValprocessRPNTokenpopperpopThroughOpen processParenpopRemainingOperators StkOpenParenStkOpprocessInfixToken$fContravariantInfixTokenunToken toksToRPN$fContravariantToken