wyo      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z [ \ ] ^ _ ` a b c d e f g h i j k lmn Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportable Safe-Inferred+0oUsing String instead of TypeRep since I wasn't sure how to avoid mandatory recursion to complete the latter. (Probably it can be done -- :~:B perhaps -- but I was unsure and this is working for the moment.)pqorsqopqors Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNone+0Only   and  allow for explicit recursion. All other - values are in leaf position when they occur.Concrete syntax for W* and T* nodes are identical. A T* node is simply a W*@ node bearing a type constraint attribute. Please refer to the GrammarN further down this page for more details, and links to even more information.Notes:I've kept the T*_ types broken out as separate constructors, although they could be handled as special cases of W* types in a way analogous to  (_). These were not "absorbed" because the semantics seems icky, and it's still not clear which W*0 types even make sense with a type constraint...I tried parametrising this, but it messed up my Show instance and seemed to be pulling me away from Haskell 98, so reverted. It looks a bit ugly in the Haddock unfortunately, with the redundant column of  PatNodeAttrs. The T* nodes will be absorbed by * in version 0.7, and it won't look so bad.*Dummy node type reserved for internal use. Fully force ( Mhttp://hackage.haskell.org/package/deepseq/docs/Control-DeepSeq.html#t:NFDatarnfo) the whole branch under this node, if the node type matches any of the types in the list; otherwise behave as ,. (Note this behaviour is the complement of   behaviour.) nhttp://hackage.haskell.org/package/deepseq-bounded-0.6.0.0/docs/Control-DeepSeq-Bounded-NFDataN.html#t:NFDataNrnfn nh the branch under this node, if the node type matches any of the types in the list; otherwise behave as .ZMatch any of the types in the list (and continue pattern matching descendants); behave as # for nodes of type not in the list. aDon't even unwrap the constructor of this node, if it's type is in the list; otherwise behave as  ,. (Note this behaviour is the complement of  behaviour.) (Wild, * )  Fully force ( Mhttp://hackage.haskell.org/package/deepseq/docs/Control-DeepSeq.html#t:NFDatarnf$) the whole branch under this node. Note that this is not !achievable as a limiting case of  , so the existence of  ' is formally justifiable in a way that  9 is not. Having said that, for all practical purposes, a   with  = maxBound::Int could be used for  ... (N (depth), *n )   nhttp://hackage.haskell.org/package/deepseq-bounded-0.6.0.0/docs/Control-DeepSeq-Bounded-NFDataN.html#t:NFDataNrnfn n the branch under this node. (Stop, !R )  Stop recursing (nothing more forced down this branch). This is equivalent to   at a  of 1.  2 is somewhat vestigial, and may be removed in 0.7. (Recurse, (...) )  Continue pattern matching descendants, provided that arity is compatible (else the match fails). Interior nodes of a pattern are always WR, i.e. WR is the only PatNode) offering explicit recursion. The rest (?S, ?N, and ?W?) are implicitly recursive, but control is only as powerful as NFDataN.(Insulate, .4 )  Don't even unwrap the constructor of this node.sThese attributes can be mixed freely. Certain combinations may seem unuseful, but nothing is prohibited by design.While this may seem bloated, most of these capabilities can be truly banished from the code via build flags (USE_PAR_PATNODE etc.).dIn the concrete pattern syntax, all attributes are represented as prefix modifiers (prefixing the '.', '!', '(' or '*'( pattern node designator), except for  and , which are postfix. Prefix modifiers may be given in any order, but the postfix must be in depth-then-type-constraints order when both are present.&Optional for convenience; set up with *. Beware that this function is not called automatically (or if it happens to be at the moment, this behaviour shouldn't be relied upon). For example, if you were to call  nhttp://hackage.haskell.org/package/deepseq-bounded-0.6.0.0/docs/Control-DeepSeq-Bounded-PatUtil.html#v:growPatgrowPat1, the added nodes would all have "uniqueID" of 0.(*n)  Depth of forcing for   and  nodes (n is decimal integer depth).(:3)  Constrain pattern to match only types named in . XXXC This should be considered experimental still in 0.6. This and the  NFDataPDyn aspects lost attention to  )http://hackage.haskell.org/package/seqaidseqaid.?The list of type rep strings used in the type constraint (when  is t).(@)  Delay (current thread) for  microseconds. XXX Still buggy?Microseconds of delay (when  is t).(=+)  Spark matching for parallel evaluation.(>permH)  Sequence child subpattern matching, according to the permutation in .GLowercase alphabetic sequence is used in the concrete pattern syntax.  >cdba(wxyz)r will cause subpattern matching recursion on a quaternary constructor, with the subpattern computations sequenced y then z then x then w (order corresponds to cdba).(+!)  Output a traceline to stderr.(^C)  Raise informative (asynchronous? support is not strong for it,  Mhttp://hackage.haskell.org/package/base/docs/Control-Exception.html#v:throwTothrowTo blocks...) exception  en passant, for benefit of upstream. The exception is thrown in a new thread, so that the pattern matching continues; for a terminating version, see .Needed as argument for throwTo call.(/)  Kill (just this) thread.(%8)  Note time passed since pattern-matched parent node. XXX Work in progress.A  !"#$u%&'()v*wxy+,-./012345z{|}~;  !"#$u%&'()v*wxy+,-./012345!   !"#$u%&'()v*wxy+,-./012345z{|}~Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com>unstableportable (CPP)None666Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNone6  !"#$%&'()*+,-./0123456"  !+,-./0123%&'()45*#$Andrew G. Seniuk 2014-2015 BSD-style (see the LICENSE file) Andrew Seniuk <rasfar@gmail.com> provisionalGHCNone &(=KM:: x is semantically the same as xJ, except its strictness, parallellism, etc. can be tweaked dynamically... /seqharn = to . hliftA (gforce_ Insulate) . fromI can see how this would be useful at compile-time, but how can we use this if seqharn only runs post-compilation? Or is it just analogous to forcep?...Also: How exactly to dynamically configure this?...789:789:978:789:Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisional:portable, except mkPat, mkPatN and growPat (which use SYB)NoneHM <Compute the union of a list of "s.jNote that unionPats is undefined when homologous nodes specify incompatible arities (only possible when   or  are involved).XXX Support for the various attributes is work in progress. It may be impossible to arrive at a consistent treatment for all attributes under unions. At the last moment, 0.6.0.0 will not be supporting type constraints under union, intersection or testing subpattern predicate. This is work in progress, but the five un-modified W* node types should be safe.=&Compute the intersection of a list of "s.Where two (or more) homologous  E nodes disagree in arity, the intersection at that position becomes .XXX* This doesn't yet handle type-constrained s ( , ,  or k). Other attributes are handled in a haphazard fashion. This is work in progress, but the five un-modified W* node types should be safe.>Return t. if the first pattern matches the second (and  otherwise).eArities must correspond (or the second pattern's node must be wild) for the match to succeed at each  recursive  (i.e.   or &). Matching does not imply spanning;  > would work for that.XXX* This doesn't yet handle type-constrained s ( , ,  or  ), because =" doesn't. Generally speaking, it is difficult to arrive at a good policy for subpattern, union and intersection, when mixed types of nodes with various attribute values are considered! Other attributes are handled in a haphazard fashion. This is work in progress, but the five un-modified W* node types should be safe./More formally, we have two "Subpattern Axioms":Not More Specifc7  A subpattern (of a pattern) is never more specific (i.e.9 less permissive), in terms of what values it will match.Not More Forcing4  A subpattern never has greater forcing potential.And a properO subpattern will always be strictly more permissive or less forcing (or both).?fGiven an integer depth and a pattern, truncate the pattern to extend to at most this requested depth.*Nodes in the truncated pattern which were  % and are now leaves, are changed to ;. (This is a change from 0.5, where they were changed to  , which violates the Subpattern Axiom concerning forcing potential. It may be further changed to 'WR'-bearing-'WI'-children in 0.7, which preserves arity info, as is consistent with the new treatment of B in 0.6.)XXX Note that *N and *W nodes are retained, so if you are using those then "extend to at most this depth" does not mean the forcing potential of the pattern is at most that depth... It would be quite possible to improve this, so *N (and *W nodes, obviously) are "weakened" (depth is reduced) so that they end at the truncation depth, regardless of how far up they reside. In particular, any *N or *W/ node at truncation depth could be replaced by WS>. This works well as all these node types are arity-agnostic.@ There is no Nil in the Pattern type, but a single o node as empty pattern is a dependable way to ensure that the empty pattern never forces anything. This sets  to %.AiObtain a lazy, potentially infinite pattern, matching the shape of an arbitrary term (value expression).There is only one kind of  employed here,  . (Note: /This is an API breaking change from 0.5, where   also occurred.)The "R is extended indefinitely on demand. In case the term has leaves, these will be  < nodes with empty child lists in the corresponding pattern.Caveat : Note that mkPatL gives counter-intuitive results when used on rose trees, in particular on "_ itself. For example, a rose tree with a single node will have a 3-node /\ shape.) Formally, A is not idempotent on "Ys, but rather grows without bound when iterated. This shouldn't be an issue in practise.BhObtain a lazy, finite pattern, matching the shape of an arbitrary term, but only down to at most depth n. Satisfies forcep . B n = forcen n. \(Later: I kinda doubt that is true in full generality?... Although it does convey the idea.)Unlike A), three pattern node contexts arise here:>those corresponding to actual leaf (nullary) nodes of the term these are   Node WR []Iinterior nodes of the pattern corresponding to interior nodes of the term these are   Node WR chs  where chs8 are the child subpatterns of this interior pattern nodeleaf nodes of the pattern corresponding to interior nodes of the term, that is, non-leaf nodes of the term which are at a depth n$ of nested constructor applications. these are   Node WR chs'  where  #chs' = map (const $ Node WI []) chsthis essentially says we're allowed to know the arity of the node, but aside from this cardinal number we know nothing whatsoever concerning the child subpatterns and are not even permitted to evaluate their headsAll interior nodes are  , and all leaf nodes are ;  2 never arise (which is a change from version 0.5).See caveat in the A documentation.CYElide all leaves which have no non-leaf sibling. We want the pattern to still match the same value, only less of it. Merely eliding all leaves would, in most cases, cause match failure, so we have to be a bit more subtle. There are some arbitrary decisions about the relaxation route through the lattice. (Refer to the source for details.)More formally, we have some "Shrinkage Axioms". The first two are really just the "Subpattern Axioms" again, that is, shrinkage is always to a subpattern in our sense of the word (see also >):Not More Specifc/  Shrinkage is never towards a more specific (i.e. less permissive) pattern.Not More ForcingG  Shrinkage is never towards a pattern with greater forcing potential.+And additionally, for finite patterns only: Non-Constancy0  A finite pattern is constant under shrinkage iff the pattern is trivial (emptyPat, ".", Node WI []). However, infinite patterns have other limits. For instance, the infinite pattern  $  "(.")> (yes you can do that!) is already stationary under shrinkage. Convergence  On iteration, shrinkage of finite patterns reaches the trivial pattern in a number of steps proportional to the size of the initial pattern argument. (Actually, *N and *W nodes can make this larger.) However, in the case of infinite patterns, all bets are off: Simple examples exist which converge immediately, or which continue shrinking indefinitely.)DyGrow all leaves by one level within the shape of the provided value. This is intended to be used with "plain" patterns, i.e. those containing only   and P nodes. (There is no code enforcing this.) A new growth node always replaces a  (leaf) node with a  & node bearing the suitable number of  children to encode arity (see A$ for general commentary about this).EThis creates a new   node, the common root, with  set to %O. The argument patterns become the children of the root (order is preserved).F7Add children to a node (interior or leaf) of the target. The first argument is target pattern, the second is a path (0-based indexing) from the root of the target to any choice node, and the third is a list of subpatterns for insertion, along with the indices of the insertion slots. Indices range through -1,0..n, where n* is the number of existing children, and -1 is short for n (so you don't need to count off the children to append!). Indices are always relative to the original target as it was received.G Elide children of a node (interior or leaf) of the target. The first argument is target pattern, the second is a path (0-based indexing) from the root of the target to any choice node, and the third is a list of child indices for elision. Indices range through  -1,0..n-1, where n* is the number of existing children, and -1 is short for n-1 (so you don't need to count off the children to elide the rightmost). Indices are always relative to the original target as it was received.HSelect a leaf at random, and elide it. In order to achieve fairness, the node probabilities are weighted by nodes in branch. The path arg can "focus" the stochastic erosion to only consider leaves beneath a given node.1;<=>?@ABCDEFGHIJKLMN1;<=>?@ABCDEFGHIJKLMN1;<=>?@ABCDEFGHIJKLMNAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNoneJ  !"#$%&'()*+,-./012345;<=>?@ABCDEFGHIJKLMN<=>ABD?C@EFGH;IJKLMNAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNone+0MAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNone+0P Inverse of O. ,showPat . compilePat patstring = patstringV(up to optional whitespace, and canonical ordering of any attributes), provided that compilePat patstring succeeds. ,(And, only up to subpatterns elided from # ( or   ) or from * ( ,  , , or 9) nodes, in case these are still accepted by the parser!)OPOPOPAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNoneOPOPAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNoneQ:A class of types that can be evaluated to arbitrary depth.SS n x y evaluates x to depth n, before returning y.This is used when expression x also appears in y, but mere evaluation of y does not force the embedded x% subexpression as deeply as we wish. The name S+ is used to illustrate the relationship to  : where P is shallow in the sense that it only evaluates the top level of its argument, S n' traverses (evaluates) the entire top n levels of the data structure.0A typical use is to ensure any exceptions hidden within lazy fields of a data structure do not leak outside the scope of the exception handler; another is to force evaluation of a data structure in one thread, before passing it to another thread (preventing work moving to the wrong threads). Unlike  Dhttp://hackage.haskell.org/package/deepseq/docs/Control-DeepSeq.htmlDeepSeqq, potentially infinite values of coinductive data types are supported by principled bounding of deep evaluation.It is also useful for diagnostic purposes when trying to understand and manipulate space/time trade-offs in lazy code, and as a less indiscriminate substitute for deepseq. Furthermore, S can sometimes be a better solution than using stict fields in your data structures, because the latter will behave strictly everywhere that its constructors are used, instead of just where its laziness is problematic.oThere may be possible applications to the prevention of resource leaks in lazy streaming, but I'm not certain. One of the special qualities of Q is shape oblivity: it doesn't care about any details of the shape of the term it's forcing, it only cares about stratifying levels of recursion depth. (I would say "as contrasted with  dhttp://hackage.haskell.org/package/deepseq-bounded-0.6.0.0/docs/Control-DeepSeq-Bounded-NFDataP.htmlNFDataP" but cannot, because  dhttp://hackage.haskell.org/package/deepseq-bounded-0.6.0.0/docs/Control-DeepSeq-Bounded-NFDataP.htmlNFDataP was extended to include  dhttp://hackage.haskell.org/package/deepseq-bounded-0.6.0.0/docs/Control-DeepSeq-Bounded-NFDataN.htmlNFDataN< syntax/capabilities, precisely to ammend this deficiency.)TT is a variant of S& that is useful in some circumstances. forcen n x = deepseqn n x x forcen n x evaluates x to depth nK, and then returns it. Recall that, in common with all Haskell functions, forcenx only performs evaluation when upstream demand actually occurs, so essentially it turns shallow evaluation into depth-n evaluation.%QRSTQRSTSTQR$QRSTAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalGHC (uses SOP)NoneHMUVWUVWUVWUVWAndrew G. Seniuk 2014-2015 BSD-style (see the LICENSE file) Andrew Seniuk <rasfar@gmail.com> provisionalGHCNone &(=KMXXXXAndrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNone&+MYHA class of types that can be evaluated over an arbitrary finite pattern.ZSelf-composition fuses via > "rnfp/composition" forall p1 p2 x. (.) (Z p2) (Z p1) x = Z ( < [p1, p2] ) x @(Other fusion rules, not yet documented, may also be in effect.)]]< evaluates the first argument to the extent specified by a ", before returning the second.Quoting from the  Dhttp://hackage.haskell.org/package/deepseq/docs/Control-DeepSeq.htmlDeepSeq documentation ( *http://hackage.haskell.org/package/deepseqdeepseq package):" Nhttp://hackage.haskell.org/package/deepseq/docs/Control-DeepSeq.html#t:deepseqdeepseq can be useful for forcing pending exceptions, eradicating space leaks, or forcing lazy I/O to happen. It is also useful in conjunction with parallel Strategies (see the  +http://hackage.haskell.org/package/parallelparallel  package).  There is no guarantee about the ordering of evaluation. The implementation may evaluate the components of the structure in any order or in parallel. To impose an actual order on evaluation, use  from Control.Parallel in the parallel package." ^Self-composition fuses via G "deepseqp_/composition" forall p1 p2 x1 x2. (.) (^ p2 x2) (^ p1 x1) = ^ ( E [p1, p2] ) (x1,x2) @(Other fusion rules, not yet documented, may also be in effect.)_ A variant of ] that is sometimes convenient: dforcep pat x = deepseqp pat x x -- (cannot write x `deepseqp pat` x by analogy with x `deepseq` x) forcep pat x evaluates x to the depth determined by pat, and then returns x. Again from  *http://hackage.haskell.org/package/deepseqdeepseq:  "Note that  forcep pat x% only takes effect when the value of  forcep pat xm itself is demanded, so essentially it turns shallow evaluation into evaluation to arbitrary bounded depth." Composition fuses (see `).`Self-composition fuses via A "forcep_/composition" forall p1 p2 x. (.) (` p2) (` p1) x = ` ( < [p1, p2] ) x @(Other fusion rules, not yet documented, may also be in effect.).YZ[\]^_`aYZ[\]^_`a,YZ[\]^_`a Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisionalportableNoneS  !"#$%&'()*+,-./012345;<=>?@ABCDEFGHIJKLMNYZ[\]^_`a ]_^`[\aYZ Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> experimentalGHCNone&=HKM bSOP/SYB hybrid dynamic ].cSOP/Typeable hybrid dynamic ].dSOP-only dynamic ].eSOP/SYB hybrid dynamic _.fSOP/Typeable hybrid dynamic _.gSOP-only dynamic _.hSOP-only dynamic Z). Takes a SOP generic function yielding R, which extends the pattern dynamically, depending on the type of the value node.iSOP/SYB hybrid dynamic Z. Takes a SYB GenericQ [ argument, which extends the pattern dynamically, depending on the type of the value node.jSOP/Typeable hybrid dynamic Z. Takes a SYB GenericQ [ argument, which extends the pattern dynamically, depending on the type of the value node.bcdefghij\  !"#$%&'()*+,-./012345;<=>?@ABCDEFGHIJKLMNYZ[\]^_`abcdefghij ibehdgjcfbcdefghijAndrew G. Seniuk 2014-2015 BSD-style (see the LICENSE file) Andrew Seniuk <rasfar@gmail.com> provisionalGHC (uses SOP)None &(=KM k     k k      Andrew G. Seniuk 2014-2015 BSD-style (see the LICENSE file) Andrew Seniuk <rasfar@gmail.com> provisionalGHC (uses SOP)NonekkAndrew G. Seniuk 2014-2015 BSD-style (see the LICENSE file) Andrew Seniuk <rasfar@gmail.com> provisionalGHCNone789XkXk978Andrew G. Seniuk 2014-2015 BSD-style (see the file LICENSE) Andrew Seniuk <rasfar@gmail.com> provisional3portable (but GHC for a few modules using generics)None24=Kn.The constraints could probably shrink to just  with a bit of work... In fact, trying it now -- to do away with NFDataN and NFDataP classes, and just "alias the SOP generic functions", as did in Seqable... [Fail. for now] lmnt  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn#$lmn6lmn             ! " # $ $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrst u v w x y z { | }~              !"#$%&'()*+,-./0120130140150167deepseq-bounded-0.6.0.0Control.DeepSeq.Bounded.PatternControl.DeepSeq.Bounded(Control.DeepSeq.Bounded.Generic.GSeqableControl.DeepSeq.Bounded.PatUtilControl.DeepSeq.Bounded.CompileControl.DeepSeq.Bounded.NFDataNControl.DeepSeq.Bounded.Seqable(Control.DeepSeq.Bounded.Generic.GNFDataNControl.DeepSeq.Bounded.NFDataP"Control.DeepSeq.Bounded.NFDataPDyn(Control.DeepSeq.Bounded.Generic.GNFDataP,Control.DeepSeq.Bounded.Compile_shared_utils+Control.DeepSeq.Bounded.Pattern_new_grammarControl.DeepSeq.Bounded.Flags+Control.DeepSeq.Bounded.PatUtil_new_grammar+Control.DeepSeq.Bounded.Compile_new_grammar-Control.DeepSeq.Bounded.Compile_shared_utils2+Control.DeepSeq.Bounded.NFDataP_new_grammar4Control.DeepSeq.Bounded.Generic.GNFDataP_new_grammarControl.DeepSeq.Bounded.GenericSeqNodeSpark PropagateInsulatePatNodeXXTWTNTRTIWWWNWSWRWI PatNodeAttrsuniqueIDdepthdoConstrainTypetypeConstraintsdoDelaydelayusdoSparkdoPseqpseqPermdoTracedoPing pingParentTIDdoDiedoTiming timestampparent_timestampdelta_timestampPatternRoseNodeemptyPatNodeAttrsgetPatNodeAttrssetPatNodeAttrssetPatNodePingParentTIDshowPermsetPatternPatNodeUniqueIDsisWIisWRisWSisWNisWWisTIisTRisTNisTW showPatRawshowPatNodeRaw2deepseq_bounded_flag__new_improved_pattern_grammargseq_gforce_grnf_seqharnShape unionPats intersectPatssubPat truncatePatemptyPatmkPatmkPatN shrinkPatgrowPatliftPats splicePats elidePatserodePatshapeOfghom probDensRose weightedRose unzipRoseshowRose compilePatshowPatNFDataNrnfndeepseqnforcenrnf_force_seq_grnfnNFDataPrnfpDeepSeqBounded_PingExceptiondeepseqp deepseqp_forcepforcep_ handleAttrs deepseqpDyn deepseqpDyn'' deepseqpDyn' forcepDyn forcepDyn'' forcepDyn'rnfpDyn'rnfpDyn rnfpDyn''grnfpFFFphicompileTypeRepsmytraceparseInt splitPred splitPred'ghc-prim GHC.TypesTrue showPerm'mapRoseM postIncrement mapRoseM'$fNFDataPatNode $fShowPatNode$fNFDataPatNodeAttrs$fNFDataThreadId $fNFDataRose $fFunctorRosegrnf_Sgrnf_PFalsebaseGHC.BaseflipGHC.ListconcatrepeatfirstWarningPassedunion' union'asym_1 union'asym_2 union'asym_3 intersect'intersect'asym_1intersect'asym_2intersect'asym_3clearTypeConstraints unionAttrs unionAttrs'intersectAttrsintersectAttrs' combineTracescombinePseqPermscombinePingParentTIDs combinePingscombineUniqueIDs combineDelaysunionTysnubsort intersectTys equilengthzipWith_ zipWith_'growPat' probDensRose' parsePatsTop parsePatsparsePat parsePat1''' parsePat1' parsePat1'' parsePat3 parsePat3_aux parsePat4 parsePat4_w parsePat4_tparsePat_WR_tailparsePat_TR_tailparse_type_constraintscompileUsingAttoparsec compilePat_descendGHC.Primseq$fNFDataN(,,,,,,,,)$fNFDataN(,,,,,,,)$fNFDataN(,,,,,,)$fNFDataN(,,,,,)$fNFDataN(,,,,)$fNFDataN(,,,) $fNFDataN(,,) $fNFDataN(,)$fNFDataNArray $fNFDataN[]$fNFDataNVersion$fNFDataNEither$fNFDataNMaybe$fNFDataNComplex$fNFDataNRatio $fNFDataN(->)$fNFDataNFixed$fNFDataNWord64$fNFDataNWord32$fNFDataNWord16$fNFDataNWord8$fNFDataNInt64$fNFDataNInt32$fNFDataNInt16 $fNFDataNInt8 $fNFDataN() $fNFDataNBool $fNFDataNChar$fNFDataNDouble$fNFDataNFloat$fNFDataNInteger $fNFDataNWord $fNFDataNIntgrnfnSgrnfnPparallel-3.2.0.5Control.Parallelpseqrnfp' patMatchFail patMatchFail'pseq_condition$fNFDataP(,,,,,,)$fNFDataP(,,,,,)$fNFDataP(,,,,)$fNFDataP(,,,) $fNFDataP(,,) $fNFDataP(,)$fNFDataPArray $fNFDataP[]$fNFDataPVersion$fNFDataPEither$fNFDataPMaybe$fNFDataPComplex$fNFDataPRatio $fNFDataP(->)$fNFDataPFixed$fNFDataPWord64$fNFDataPWord32$fNFDataPWord16$fNFDataPWord8$fNFDataPInt64$fNFDataPInt32$fNFDataPInt16 $fNFDataPInt8 $fNFDataP() $fNFDataPBool $fNFDataPChar$fNFDataPDouble$fNFDataPFloat$fNFDataPInteger $fNFDataPWord $fNFDataPInt'$fExceptionDeepSeqBounded_PingException rnfpDynS' rnfpDynP'rnfpDynSrnfpDynP rnfpDyn''S rnfpDyn''Pmytrace'grnfp'grnfpSgrnfpPgrnfpP_validategrnfpP_validate'lenxspatMatchFail''generics-sop-0.1.1Generics.SOP.UniverseGenericFPatternFIntFSeqNode TFCo:R:FRosev$fFFRose TFCo:R:FIntv$fFFIntTFCo:R:FSeqNodev $fFFSeqNodedeepseq-1.3.0.2Control.DeepSeqforce$!!deepseqrnfNFData