ú΁ºlÆÎ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh i j k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ¡ ¢ £ € ¥ Š § š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍ Safe-InferedÎGHCs foldr/build system, but on all platforms ÏÐ), but suitable for inlining. Copied from Data.ByteString.Base. Ñ(Perform concatentation of continuations ÎÏÑÐÒÎÏÑÎÏÑ Safe-Infered Invariant preserving version of IntSet from the  containers! packages, suitable for use with Uniplate.  Use  to construct values, and  to deconstruct values.  Invariant preserving version of IntMap from the  containers! packages, suitable for use with Uniplate.  Use  to construct values, and  to deconstruct values.  Invariant preserving version of Set from the  containers! packages, suitable for use with Uniplate.  Use  to construct values, and  to deconstruct values.  Invariant preserving version of Map from the  containers! packages, suitable for use with Uniplate.  Use  to construct values, and  to deconstruct values. The  data type as a Ó* instance which reports as being defined:   data Invariant a = Invariant a However, whenever a Ô6 constructs a new value, it will have the function in  the % field applied to it. As an example:  I data SortedList a = SortedList (Invariant [a]) deriving (Data,Typeable) 9 toSortedList xs = SortedList $ Invariant sort (sort xs) 3 fromSortedList (SortedList (Invariant _ xs)) = xs Any time an operation such as Õ" is applied to the data type, the  function ! is applied to the result. The fromSortedList+ function can then rely on this invariant. The ÖQ method is partially implemented - all constructed values will have an undefined C value for all fields, regardless of which function is passed to ×. If you only use  Ø (as Uniplate does) then the Ö method is sufficient. The  data type has a Ó* instance which reports as being defined:   data Trigger a = Trigger a However, whenever a Ô or Ö* constructs a new value, it will have the    field set to Ù8. The trigger information is useful to indicate whether I any invariants have been broken, and thus need fixing. As an example:  G data SortedList a = SortedList (Trigger [a]) deriving (Data,Typeable) 8 toSortedList xs = SortedList $ Trigger False $ sort xs H fromSortedList (SortedList (Trigger t xs)) = if t then sort xs else xs ZThis data type represents a sorted list. When constructed the items are initially sorted,  but operations such as Õ! could break that invariant. The  type is used to M detect when the Data operations have been performed, and resort the list. The ( type is often used in conjunction with , which fixes the invariants. The   data type has a Ó0 instance which reports having no constructors, 9 as though the type was defined as using the extension EmptyDataDecls:   data Hide a TThis type is suitable for defining regions that are avoided by Uniplate traversals.  As an example:  C transformBi (+1) (1, 2, Hide 3, Just 4) == (2, 3, Hide 3, Just 4) @As a result of having no constructors, any calls to the methods Ú or Ö  will raise an error. Deconstruct a value of type . Construct a value of type . Deconstruct a value of type . Construct a value of type . Deconstruct a value of type . Construct a value of type . Deconstruct a value of type . Construct a value of type . * ÛÜÝÞßàáâãäåæçèéêëìí   "  ÛÜÝÞßàáâãäåæçèéêëìí Safe-Inferedî unsafeCoerce=, but for all compilers. In future this can be obtained from  Unsafe.Coerce.unsafeCoerce!, but thats too recent a change. ïGHCs foldr/build system, but on all platforms ðunsafePerformIO), but suitable for inlining. Copied from Data.ByteString.Base. ñ(Perform concatentation of continuations îïðñîïðñîïðñ Safe-Infered9The standard Uniplate class, all operations require this #The underlying method in the class R uniplate (Add (Val 1) (Neg (Val 2))) = ([Val 1, Neg (Val 2)], \[a,b] -> Add a b) R uniplate (Val 1) = ([] , \[] -> Val 1 ) 1The type of replacing all the children of a node FTaking a value, the function should return all the immediate children 5 of the same type, and a function to replace them. CGet all the children of a node, including itself and all children.  ( universe (Add (Val 1) (Neg (Val 2))) = < [Add (Val 1) (Neg (Val 2)), Val 1, Neg (Val 2), Val 2] FThis method is often combined with a list comprehension, for example: $ vals x = [i | Val i <- universe x] 1Get the direct children of a node. Usually using  is more appropriate. children = fst . <Transform every element in the tree, in a bottom-up manner. 8For example, replacing negative literals with literals:  negLits = transform f + where f (Neg (Lit i)) = Lit (negate i)  f x = x Monadic variant of  LRewrite by applying a rule everywhere you can. Ensures that the rule cannot $ be applied anywhere in the result:  @ propRewrite r x = all (isNothing . r) (universe (rewrite r x)) Usually  is more appropriate, but  can give better 4 compositionality. Given two single transformations f and g , you can  construct f ò g3 which performs both rewrites until a fixed point. Monadic variant of  PPerform a transformation on all the immediate children, then combine them back. Q This operation allows additional information to be passed downwards, and can be , used to provide a top-down transformation. !Monadic variant of   "#Return all the contexts and holes. 5 propUniverse x = universe x == map fst (contexts x) 3 propId x = all (== x) [b a | (a,b) <- contexts x] #The one depth version of " 2 propChildren x = children x == map fst (holes x) 0 propId x = all (== x) [b a | (a,b) <- holes x] $/Perform a fold-like computation on each value,  technically a paramorphism  !"#$ !"#$ !"#$  !"#$ Safe-Infered%)Return all the top most children of type to within from. If  from == to9 then this function should return the root as the single  child. '"Return the children of a type. If  to == from then it returns the " original element (in contrast to ) 0Used for defining instances UniplateFoo a => UniplateFoo [a] %&'()*+,-./0 !"#$%&'()*+,-./0 %&'()*+,-./0 %&'()*+,-./0 Safe-Infered52Take the type of the method, will crash if called 6 Convert a 1* to a list, assumes the value was created  with 7 7Convert a list to a 1 8 Transform a 1+ to a list, and back again, in a structure ? preserving way. The output and input lists must be equal in  length. 12345678óôõö1234567814325678 14325678óôõö Safe-Infered96Children are defined as the top-most items of type to  starting at the root. All instances must define :, while  ; and < are optional. :)Return all the top most children of type to within from. If  from == to9 then this function should return the root as the single  child. ;Like ?! but with more general types. If  from == to then this  function does not4 descend. Therefore, when writing definitions it is L highly unlikely that this function should be used in the recursive case. 6 A common pattern is to first match the types using ;, then continue  the recursion with ?. =OThe standard Uniplate class, all operations require this. All definitions must  define >, while ? and @ are optional. >$The underlying method in the class. I Taking a value, the function should return all the immediate children 5 of the same type, and a function to replace them. Given uniplate x = (cs, gen) cs should be a Str on, constructed of Zero, One and Two,  containing all x'&s direct children of the same type as x. gen  should take a Str on$ with exactly the same structure as cs, : and generate a new element with the children replaced. Example instance:  instance Uniplate Expr where S uniplate (Val i ) = (Zero , \Zero -> Val i ) S uniplate (Neg a ) = (One a , \(One a) -> Neg a ) S uniplate (Add a b) = (Two (One a) (One b), \(Two (One a) (One b)) -> Add a b) ?PPerform a transformation on all the immediate children, then combine them back. S This operation allows additional information to be passed downwards, and can be W used to provide a top-down transformation. This function can be defined explicitly, 3 or can be provided by automatically in terms of >. 1For example, on the sample type, we could write:  descend f (Val i ) = Val i ! descend f (Neg a ) = Neg (f a) ' descend f (Add a b) = Add (f a) (f b) @Monadic variant of ? ACGet all the children of a node, including itself and all children.  ( universe (Add (Val 1) (Neg (Val 2))) = < [Add (Val 1) (Neg (Val 2)), Val 1, Neg (Val 2), Val 2] FThis method is often combined with a list comprehension, for example: $ vals x = [i | Val i <- universe x] B1Get the direct children of a node. Usually using A is more appropriate. C<Transform every element in the tree, in a bottom-up manner. 8For example, replacing negative literals with literals:  negLits = transform f + where f (Neg (Lit i)) = Lit (negate i)  f x = x DMonadic variant of C ELRewrite by applying a rule everywhere you can. Ensures that the rule cannot $ be applied anywhere in the result:  @ propRewrite r x = all (isNothing . r) (universe (rewrite r x)) Usually C is more appropriate, but E can give better 4 compositionality. Given two single transformations f and g , you can  construct f mplus g3 which performs both rewrites until a fixed point. FMonadic variant of E G#Return all the contexts and holes. $ universe x == map fst (contexts x) ( all (== x) [b a | (a,b) <- contexts x] HThe one depth version of G ! children x == map fst (holes x) % all (== x) [b a | (a,b) <- holes x] I/Perform a fold-like computation on each value,  technically a paramorphism K"Return the children of a type. If  to == from then it returns the " original element (in contrast to B) 9:;<=>?@ABCDEFGHIJKLMNOPQ9:;<=>?@ABCDEFGHIJKLMNOPQ=>?@9:;<ABCDEFGHIJKLMNOPQ9:;<=>?@ABCDEFGHIJKLMNOPQ Safe-InferedR+If you want to keep an existing type class S  composOp == ?T  composOpM == @U composOpM_ == X (return ()) (>>)V composOpMonoid = X mempty mappendW composOpMPlus = X mzero mplusXProbably replace with A , perhaps I RSTUVWXRSTUVWXRSTUVWXRSTUVWX Safe-Infered Y  gmapT == ?ZUse B and ÷ [Use B and ø \Use B ]Use B and ù ^  gmapM == @_ mkT == ú` everywhere == La  mkM == idb everywhereM == McOnly for use with d dUse A or J, perhaps followed by a fold. #Not an exact equivalent to the SYB  everything , as the 1 operators may be applied in different orders. YZ[\]^_`abcd YZ[\]^_`abcd YZ[\]^_`abcd YZ[\]^_`abcd Safe-Inferedû:An existential box representing a type which supports SYB  operations. f Wrap up a (a -> a)& transformation function, to use with g gSApply a sequence of transformations in order. This function obeys the equivalence:  [ transformBis [[transformer f],[transformer g],...] == transformBi f . transformBi g . ... Each item of type  [Transformer]0 is applied in turn, right to left. Within each   [Transformer], the individual  Transformer values may be interleaved. UThe implementation will attempt to perform fusion, and avoid walking any part of the W data structure more than necessary. To further improve performance, you may wish to _ partially apply the first argument, which will calculate information about the relationship  between the transformations. ;eüýþÿû      !"#$%&'()*+,-./0f1g2;eüýþÿû      !"#$%&'()*+,-./0f1g2.eüýþÿû      !"#$%&'()*+,-./0f1g2 Safe-Infered349:;<=>?@ABCDEFGHIJKLMNOPQefggef34 Safe-Inferedh6Children are defined as the top-most items of type to  starting at the root. All instances must define i, while  j and k are optional. i)Return all the top most children of type to within from. If  from == to9 then this function should return the root as the single  child. jLike n! but with more general types. If  from == to then this  function does not4 descend. Therefore, when writing definitions it is L highly unlikely that this function should be used in the recursive case. 6 A common pattern is to first match the types using j, then continue  the recursion with n. lOThe standard Uniplate class, all operations require this. All definitions must  define m, while n and o are optional. m$The underlying method in the class. I Taking a value, the function should return all the immediate children 5 of the same type, and a function to replace them. Given uniplate x = (cs, gen) cs should be a Str on, constructed of Zero, One and Two,  containing all x'&s direct children of the same type as x. gen  should take a Str on$ with exactly the same structure as cs, : and generate a new element with the children replaced. Example instance:  instance Uniplate Expr where S uniplate (Val i ) = (Zero , \Zero -> Val i ) S uniplate (Neg a ) = (One a , \(One a) -> Neg a ) S uniplate (Add a b) = (Two (One a) (One b), \(Two (One a) (One b)) -> Add a b) nPPerform a transformation on all the immediate children, then combine them back. S This operation allows additional information to be passed downwards, and can be W used to provide a top-down transformation. This function can be defined explicitly, 3 or can be provided by automatically in terms of m. 1For example, on the sample type, we could write:  descend f (Val i ) = Val i ! descend f (Neg a ) = Neg (f a) ' descend f (Add a b) = Add (f a) (f b) oMonadic variant of n pCGet all the children of a node, including itself and all children.  ( universe (Add (Val 1) (Neg (Val 2))) = < [Add (Val 1) (Neg (Val 2)), Val 1, Neg (Val 2), Val 2] FThis method is often combined with a list comprehension, for example: $ vals x = [i | Val i <- universe x] q1Get the direct children of a node. Usually using p is more appropriate. r<Transform every element in the tree, in a bottom-up manner. 8For example, replacing negative literals with literals:  negLits = transform f + where f (Neg (Lit i)) = Lit (negate i)  f x = x sMonadic variant of r tLRewrite by applying a rule everywhere you can. Ensures that the rule cannot $ be applied anywhere in the result:  @ propRewrite r x = all (isNothing . r) (universe (rewrite r x)) Usually r is more appropriate, but t can give better 4 compositionality. Given two single transformations f and g , you can  construct f mplus g3 which performs both rewrites until a fixed point. uMonadic variant of t v#Return all the contexts and holes. $ universe x == map fst (contexts x) ( all (== x) [b a | (a,b) <- contexts x] wThe one depth version of v ! children x == map fst (holes x) % all (== x) [b a | (a,b) <- holes x] x/Perform a fold-like computation on each value,  technically a paramorphism z"Return the children of a type. If  to == from then it returns the " original element (in contrast to q) hijklmnopqrstuvwxyz{|}~€hijklmnopqrstuvwxyz{|}~€hijklmnopqrstuvwxyz{|}~€  Safe-Infered56efghijklmnopqrstuvwxyz{|}~€lmnohijkpqrstuvwxyz{|}~€gef56  Safe-Infered-The main combinator used to start the chain. 1The following rule can be used for optimisation: # plate Ctor |- x == plate (Ctor x) ‚&The field to the right is the target. ƒ/The field to the right may contain the target. „The field to the right does not contain the target. …;The field to the right is a list of the type of the target †GThe field to the right is a list of types which may contain the target ‡ Used for 9, definitions where both types are the same. ˆ*Write an instance in terms of a projection/1injection pair. Usually used to define instances ( for abstract containers such as Map:  2 instance Biplate (Map.Map [Char] Int) Char where 4 biplate = plateProject Map.toList Map.fromList @If the types ensure that no operations will not change the keys  we can use the fromDistictAscList" function to reconstruct the Map: 1 instance Biplate (Map.Map [Char] Int) Int where B biplate = plateProject Map.toAscList Map.fromDistinctAscList ‚ƒ„…†‡ˆ789:;<=>?@ABC!9:;<=>?@ABCDEFGHIJKLMNOPQ‚ƒ„…†‡ˆ‡ƒ„‚†…ˆ‚ƒ„…†‡ˆ789:;<=>?@ABC  Safe-Infered‰=This class should be defined for each data type of interest. Š$This method should be defined using ‹ and Œ, . ‹-The main combinator used to start the chain. Œ/The field to the right may contain the target. The field to the right does not contain the target. N This can be used as either an optimisation, or more commonly for excluding  primitives such as Int. Ž*Write an instance in terms of a projection/1injection pair. Usually used to define instances ( for abstract containers such as Map: F instance (Ord a, Typeable a, PlateAll a c, Typeable b, PlateAll b c, F Typeable c, PlateAll c c) => PlateAll (Map.Map a b) c where 5 plateAll = plateProject Map.toList Map.fromList ‰Š‹ŒŽDEFGHIJKLMNOPQRSTLUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€9:;<=>?@ABCDEFGHIJKLMNOPQ‰Š‹ŒŽ‰Š‹ŒŽ‰Š‹ŒŽDEFGHIJKLMNOPQRST  Safe-Infered HZipper structure, whose root type is the first type argument, and whose + focus type is the second type argument. 0Create a zipper, focused on the top-left value. ‘MCreate a zipper with a different focus type from the outer type. Will return  NothingH if there are no instances of the focus type within the original value. ’EFrom a zipper take the whole structure, including any modifications. “.Move one step left from the current position. ”/Move one step right from the current position. •.Move one step down from the current position. –,Move one step up from the current position. —+Retrieve the current focus of the zipper.. ˜8Replace the value currently at the focus of the zipper. ‘’“”•–—˜‚ƒ ‘’“”•–—˜ ‘’“”–•—˜ ‘’“”•–—˜‚ƒ  Safe-Infered™:The standard Uniplate class, all operations require this. š$The underlying method in the class. Given uniplate x = (cs, gen) cs should be a Str on, constructed of Zero, One and Two,  containing all x'&s direct children of the same type as x. gen  should take a Str on$ with exactly the same structure as cs, : and generate a new element with the children replaced. Example instance:  instance Uniplate Expr where S uniplate (Val i ) = (Zero , \Zero -> Val i ) S uniplate (Neg a ) = (One a , \(One a) -> Neg a ) S uniplate (Add a b) = (Two (One a) (One b), \(Two (One a) (One b)) -> Add a b) ›1The type of replacing all the children of a node FTaking a value, the function should return all the immediate children 5 of the same type, and a function to replace them. œ=Compatibility method, for direct users of the old list-based š function CGet all the children of a node, including itself and all children.  ( universe (Add (Val 1) (Neg (Val 2))) = < [Add (Val 1) (Neg (Val 2)), Val 1, Neg (Val 2), Val 2] FThis method is often combined with a list comprehension, for example: $ vals x = [i | Val i <- universe x] ž1Get the direct children of a node. Usually using  is more appropriate. children = fst . šŸ<Transform every element in the tree, in a bottom-up manner. 8For example, replacing negative literals with literals:  negLits = transform f + where f (Neg (Lit i)) = Lit (negate i)  f x = x  Monadic variant of Ÿ ¡LRewrite by applying a rule everywhere you can. Ensures that the rule cannot $ be applied anywhere in the result:  @ propRewrite r x = all (isNothing . r) (universe (rewrite r x)) Usually Ÿ is more appropriate, but ¡ can give better 4 compositionality. Given two single transformations f and g , you can  construct f ò g3 which performs both rewrites until a fixed point. ¢Monadic variant of ¡ £PPerform a transformation on all the immediate children, then combine them back. Q This operation allows additional information to be passed downwards, and can be , used to provide a top-down transformation. €Monadic variant of £ ¥#Return all the contexts and holes. 5 propUniverse x = universe x == map fst (contexts x) 3 propId x = all (== x) [b a | (a,b) <- contexts x] ŠThe one depth version of ¥ 2 propChildren x = children x == map fst (holes x) 0 propId x = all (== x) [b a | (a,b) <- holes x] §/Perform a fold-like computation on each value,  technically a paramorphism ™š›œžŸ ¡¢£€¥Š§12345678™š›œžŸ ¡¢£€¥Š§›™šœžŸ ¡¢£€¥Š§™š›œžŸ ¡¢£€¥Š§ Safe-Inferedš)Return all the top most children of type to within from. If  from == to9 then this function should return the root as the single  child. ª"Return the children of a type. If  to == from then it returns the " original element (in contrast to ž) ³Used for defining instances UniplateFoo a => UniplateFoo [a] š©ª«¬­®¯°±²³#12345678™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³ š©ª«¬­®¯°±²³ š©ª«¬­®¯°±²³ Safe-InferedŽ6Children are defined as the top-most items of type to  starting at the root. ¶.Compatibility method, for direct users of the µ function Žµ¶·ž¹º»ŒœŸ¿À012345678™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿À Žµ¶·ž¹º»ŒœŸ¿À Žµ¶·ž¹º»ŒœŸ¿À Safe-InferedÁ-The main combinator used to start the chain. 1The following rule can be used for optimisation: # plate Ctor |- x == plate (Ctor x) Â&The field to the right is the target. Ã/The field to the right may contain the target. ÄThe field to the right does not contain the target. Å;The field to the right is a list of the type of the target ÆGThe field to the right is a list of types which may contain the target Ç Used for PlayAll, definitions where both types are the same. ÁÂÃÄÅÆÇ712345678™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿ÀÁÂÃÄÅÆÇÁÇÃÄÂÆÅÁÂÃÄÅÆÇ Safe-InferedÈCThis class represents going from the container type to the target. +This class should only be constructed with Ë, Ì and Í Ê!This function is used to write a ™ instance from a È one Ë-The main combinator used to start the chain. 1The following rule can be used for optimisation: # plate Ctor |- x == plate (Ctor x) Ì/the field to the right may contain the target. ÍThe field to the right does not contain the target. L This can be used as either an optimisation, or more commonly for excluding  primitives such as Int. ÈÉÊËÌÍ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™cUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€12345678™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿ÀÈÉÊËÌÍÈÉÊËÌÍÈÉÊËÌÍ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™ Safe-Inferedš›012345678™š›œžŸ ¡¢£€¥Š§š©ª«¬­®¯°±²³Žµ¶·ž¹º»ŒœŸ¿Àš›œ !!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP+,45./0123678QRSTUVWXYZ[\]^_`abcdefghijklmnMNOP+,45./0123678QRSTUVWX o p q r s t u v w x o q r v y z { | } ~  €  ‚ + , - ƒ . / 0 1 2 3 4 5 6 7 89:;<=>?@ABCDMN„QRSTUVOPWXopqrstuwx…oqr†‡ˆ‰Š‹ˆŒˆŽˆŽˆŽ`ˆŽ‘ˆŽ’ˆŽ“”•–ˆŽ—˜™š›œžŸ ¡¢£€¥Š§š©ª«†‡‹ˆ¬­®¯°±ˆ²³ˆŽµˆ²¶ˆŽ·žl¹ºº»ŒžœŸ¿ÀÁÂÂÃÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëì ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ          ì ëˆ  ˆ  ˆ  ˆ  ˆ ˆ ˆ ˆ ˆˆˆˆˆˆˆ ˆ ˆ ˆ ˆ ˆ ˆ ˆ  ˆ !ˆ "ˆ #ˆ $ˆ %ˆ &ˆ 'ˆ (ˆ )ˆ *ˆ +ˆ ,ˆ -ˆ .ˆ /ˆ 0ˆ 1ˆ 2ˆ3ˆ 4ˆ 5ˆ 6ˆ 7 8 9ûüýþÿóôõö÷øùëëì:uniplate-1.6.7%Data.Generics.Uniplate.Data.InstancesData.Generics.UniplateData.Generics.UniplateOnData.Generics.Str!Data.Generics.Uniplate.OperationsData.Generics.ComposData.Generics.SYBData.Generics.Uniplate.DataData.Generics.Uniplate.DataOnlyData.Generics.Uniplate.DirectData.Generics.Uniplate.TypeableData.Generics.Uniplate.ZipperData.Generics.UniplateStrData.Generics.UniplateStrOnData.Generics.BiplateData.Generics.PlateDirectData.Generics.PlateTypeable%Data.Generics.Uniplate.Internal.UtilsData.Generics.PlateInternal$Data.Generics.Uniplate.Internal.Data2Data.Generics.Uniplate.Internal.DataOnlyOperationsData.Generics.PlateDataIntSetIntMapSetMap Invariant invariant fromInvariantTriggertrigger fromTriggerHidefromHidefromMaptoMapfromSettoSet fromIntMaptoIntMap fromIntSettoIntSetUniplateuniplate UniplateTypeuniversechildren transform transformMrewriterewriteMdescenddescendMcontextsholespara BiplateType universeOn childrenOn transformOn transformOnM rewriteOn rewriteOnM descendOn descendOnMholesOn contextsOnuniplateOnListStrTwoOneZerostrTypestrListlistStr strStructureBiplatebiplate descendBi descendBiM universeBi childrenBi transformBi transformBiM rewriteBi rewriteBiM contextsBiholesBiComposcomposOp composOpM composOpM_composOpMonoid composOpMPlus composOpFoldgmapTgmapQlgmapQrgmapQgmapQigmapMmkT everywheremkM everywhereMmkQ everything Transformer transformer transformBisplate|*|+|-||*||+ plateSelf plateProjectPlateAllplateAllZipperzipperzipperBi fromZipperleftrightdownuphole replaceHole uniplateList biplateList uniplateAllbuilderinlinePerformIObaseGHC.IOunsafePerformIO concatCont Unsafe.Coerce unsafeCoerce Data.DataDatagfoldlgunfold fromConstrB fromConstrghc-prim GHC.TypesTruetoConstr $fOrdIntSet $fEqIntSet $fShowIntSet $fOrdIntMap $fEqIntMap $fShowIntMap$fOrdSet$fEqSet $fShowSet$fOrdMap$fEqMap $fShowMap$fDataInvariant$fShowInvariant $fDataTrigger$fFunctorTrigger $fDataHide $fFunctorHide $fShowHide unsafeCast Control.Monadmplus$fTraversableStr $fFoldableStr $fFunctorStr$fEqStrGHC.ListfoldlGHC.Basefoldr!!idDataBoxCCCfromCHitMap dataBoxKey dataBoxValFollowerIntMap2TypeMap2CacheOracle fromOracleAnswerMissFollowHitfromHitTypeKeyTypeMapTypeSettypeKey!map_findWithDefaultmap_fromAscList map_keysSet map_member set_partition set_toAscList set_unionsuniplateVerbosehitTestcachereadCacheFollowerreadCacheHitMaplookup2insert2 intLookup2 intInsert2followerdataBox sybChildren emptyHitMap insertHitMapfixEq biplateData uniplateData descendData descendBiData transformer_ transformBis_ $fBiplateab $fUniplatea$fBiplateRatioInteger$fBiplateRatioRatio$fUniplateRatio $fBiplate[][]$fBiplate[]Char $fUniplate[] $fUniplate()$fUniplateFloat$fUniplateDouble$fUniplateInteger$fUniplateChar$fUniplateBool $fUniplateInt$fPlateAllRatioto$fPlateAll(,,,,)to$fPlateAll(,,,)to$fPlateAll(,,)to$fPlateAll(,)to$fPlateAllEitherto$fPlateAllMaybeto$fPlateAll[]to$fPlateAll()to$fPlateAllFloatto$fPlateAllDoubleto$fPlateAllIntegerto$fPlateAllCharto$fPlateAllBoolto$fPlateAllInttoData.Typeable.InternalTypeable Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7 Data.Typeablegcast2gcast1gcastmkTyCon typeRepKey TypeRepKey showsTypeReptypeOf6DefaulttypeOf5DefaulttypeOf4DefaulttypeOf3DefaulttypeOf2DefaulttypeOf1Default typeOfDefault tyConString typeRepArgs typeRepTyConmkTyCon3mkAppTy funResultTy splitTyConAppmkFunTy tyConName tyConModule tyConPackagetypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7cast mkTyConAppTypeRepTyContypeOf$fEqZipN $fEqZipper