úÎ~ăȘ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   Ą ą Ł €„Š§š©ȘGHCs foldr/build system, but on all platforms «Ź), but suitable for inlining. Copied from Data.ByteString.Base. ­(Perform concatentation of continuations ŹźȘ«­Ș«­Ż 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 Ż°±ČŻ°±Č9The 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     )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]    2Take the type of the method, will crash if called  Convert a * to a list, assumes the value was created  with   Convert a list to a  ! Transform a + to a list, and back again, in a structure ? preserving way. The output and input lists must be equal in  length.  ! ! !"6Children are defined as the top-most items of type to  starting at the root. #)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. $%&:The standard Uniplate class, all operations require this. '$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 . used to provide a top-down transformation. )Monadic variant of ( *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. ,<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 mplus g3 which performs both rewrites until a fixed point. /Monadic variant of . 0#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] 1The one depth version of 0 2 propChildren x = children x == map fst (holes x) 0 propId x = all (== x) [b a | (a,b) <- holes x] 2/Perform a fold-like computation on each value,  technically a paramorphism 34"Return the children of a type. If  to == from then it returns the " original element (in contrast to +) 56789:"#$%&'()*+,-./0123456789:&'()"#$%*+,-./0123456789:"#$%#$%&'()'()*+,-./0123456789:;+If you want to keep an existing type class <  composOp == (=  composOpM == )> composOpM_ == A (return ()) (>>)? composOpMonoid = A mempty mappend@ composOpMPlus = A mzero mplusAProbably replace with * , perhaps 2 ;<=>?@A;<=>?@A;<=>?@A B  gmapT == (CUse + and Ž DUse + and ” EUse + FUse + and ¶ G  gmapM == )H mkT == ·I everywhere == 5J  mkM == idK everywhereM == 6LOnly for use with M MUse * or 3, perhaps followed by a fold. #Not an exact equivalent to the SYB  everything , as the 1 operators may be applied in different orders. BCDEFGHIJKLM BCDEFGHIJKLM BCDEFGHIJKLM žN-The main combinator used to start the chain. 1The following rule can be used for optimisation: # plate Ctor |- x == plate (Ctor x) O&The field to the right is the target. P/The field to the right may contain the target. QThe field to the right does not contain the target. R;The field to the right is a list of the type of the target SGThe field to the right is a list of types which may contain the target T Used for ", definitions where both types are the same. U*Write an instance in terms of a projection/1injection pair. Usually used to define instances ( for abstract containers such as Map:  1 instance Biplate (Map.Map [Char] Int) Int where B biplate = plateProject Map.toAscList Map.fromDistinctAscList CBecause we know that Uniplate operations will not change the keys,  we can use the fromDistictAscList function to reconstruct it. !"#$%&'()*+,-./0123456789:NOPQRSTUNTPQOSRUNOPQRSTUV=This class should be defined for each data type of interest. W$This method should be defined using X and Y, Z. čșX-The main combinator used to start the chain. Y/The field to the right may contain the target. ZThe 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 G»ŒœŸżÀÁÂĂÄĆÆÇÈÉÊËÌÍÎÏĐŃÒÓÔŐÖŚŰÙÚÛÜĘȚßàáâ"#$%&'()*+,-./0123456789:VWXYZ[VWXYZ[VWWXYZ[&ăäćæçè:An existential box representing a type which supports SYB  operations. éêëìíîïđńòóôőöśűùúûüęțÿ&ăäćæçèéêëìíîïđńòóôőöśűùúûüęțÿ&ăäćæćæçèéêëéêëìíîïđđńòóòóôśöőűőöśűùúûüęțÿ"#$%&'()*+,-./0123456789:\6Children are defined as the top-most items of type to  starting at the root. ])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. ^_`:The standard Uniplate class, all operations require this. a$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) bPPerform a transformation on all the immediate children, then combine them back. S This operation allows additional information to be passed downwards, and can be . used to provide a top-down transformation. cMonadic variant of b dCGet 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] e1Get the direct children of a node. Usually using d is more appropriate. f<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 gMonadic variant of f hLRewrite 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 f is more appropriate, but h 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. iMonadic variant of h j#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] kThe one depth version of j 2 propChildren x = children x == map fst (holes x) 0 propId x = all (== x) [b a | (a,b) <- holes x] l/Perform a fold-like computation on each value,  technically a paramorphism mn"Return the children of a type. If  to == from then it returns the " original element (in contrast to e) opqrst\]^_`abcdefghijklmnopqrst\]^_]^_`abcabcdefghijklmnopqrst \]^_`abcdefghijklmnopqrst`abc\]^_defghijklmnopqrst u:The standard Uniplate class, all operations require this. v$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) w1The 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. x=Compatibility method, for direct users of the old list-based v function yCGet 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] z1Get the direct children of a node. Usually using y is more appropriate. children = fst . v{<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  !uvwxyz{|}~€‚ƒwuvxyz{|}~€‚ƒuvvwxyz{|}~€‚ƒ „)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 z) ‡ˆ‰Š‹ŒŽUsed for defining instances UniplateFoo a => UniplateFoo [a] # !uvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ „…†‡ˆ‰Š‹ŒŽ „…†‡ˆ‰Š‹ŒŽ 6Children are defined as the top-most items of type to  starting at the root. ‘’.Compatibility method, for direct users of the ‘ function “”•–—˜™š›œ0 !uvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œ ‘’“”•–—˜™š›œ ‘‘’“”•–—˜™š›œ  -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. 7 !uvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄąŁŁŸ žąĄžŸ ĄąŁ€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 u 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. ^»ŒœŸżÀÁÂĂÄĆÆÇÈÉÊËÌÍÎÏĐŃÒÓÔŐÖŚŰÙÚÛÜĘȚßàáâ !uvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œ€„Š§š©€„Š§š©€„„Š§š©  :An existential box representing a type which supports SYB  operations. 0 !uvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œ !"#$%&'()*+,-./0123456789: !";<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_VXY]789: !";<=>?@AB    `         ! " # $ % & ' ( ) * + , - . 7 8 a ; < = > ? @ 9 : A B V W X Y Z [ \^_bVXYcdefgheijkcdhelmenoepqenrepsttuevwevxevyevzev{ev|ev}ev~evev€evev‚evƒev„ev…ev†ev‡evˆev‰evŠev‹evŒevevŽevevev‘ev’ev“ev”ev•ev–ev—ev˜ev™evšev›evœevevžŸ  ĄąŁŁ€„Š§š©©ȘȘ«Ź­źŻ°±ČłŽ”¶·žčș»ŒœŸżÀ ttuŸ  ĄŹ­źŻ°ÁÁÂŁŁĂÄĆÆÇÈ uniplate-1.5Data.Generics.UniplateData.Generics.UniplateOnData.Generics.Str!Data.Generics.Uniplate.OperationsData.Generics.ComposData.Generics.SYBData.Generics.Uniplate.DirectData.Generics.Uniplate.TypeableData.Generics.Uniplate.DataOnlyData.Generics.UniplateStrData.Generics.UniplateStrOnData.Generics.BiplateData.Generics.PlateDirectData.Generics.PlateTypeable%Data.Generics.Uniplate.Internal.UtilsData.Generics.PlateInternal$Data.Generics.Uniplate.Internal.DataData.Generics.Uniplate.Data2Data.Generics.Uniplate.Internal.DataOnlyOperationsData.Generics.PlateDataUniplateuniplate 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 everythingplate|*|+|-||*||+ plateSelf plateProjectPlateAllplateAll uniplateList biplateList uniplateAllbuilderinlinePerformIObaseGHC.IOunsafePerformIO concatCont Unsafe.Coerce unsafeCoerce unsafeCast Control.MonadmplusGHC.ListfoldlGHC.Basefoldr!!idType plateMore Data.TypeableTypeable Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7gcast2gcast1gcasttypeOf6DefaulttypeOf5DefaulttypeOf4DefaulttypeOf3DefaulttypeOf2DefaulttypeOf1Default typeOfDefault showsTypeRep tyConString typeRepArgs typeRepTyConmkAppTy funResultTy splitTyConAppmkFunTy typeRepKeytypeOf1typeOf2typeOf3typeOf4typeOf5typeOf6typeOf7TypeRepTyContypeOfmkTyCon mkTyConAppcastCCCfromCHitMapDataBox dataBoxKey dataBoxValTypeKeyFollowerIntMap2CacheOracle fromOracleAnswerMissFollowHitfromHithitTestcache readCachelookup2insert2followertypeKeydataBox sybChildren emptyHitMap insertHitMapfixEq biplateData uniplateData descendData descendBiDataBoxfromBox containsMatch containsListcontainscollect_generate_selfcollect_generate