h$rir      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                        Safe-Inferred3iuniplate Invariant preserving version of IntSet from the  containers! packages, suitable for use with Uniplate . Use  to construct values, and  to deconstruct values.uniplate Invariant preserving version of IntMap from the  containers! packages, suitable for use with Uniplate . Use  to construct values, and  to deconstruct values.uniplate Invariant preserving version of Set from the  containers! packages, suitable for use with Uniplate . Use  to construct values, and  to deconstruct values.uniplate Invariant preserving version of Map from the  containers! packages, suitable for use with Uniplate . Use  to construct values, and  to deconstruct values.uniplateThe  data type as a ) instance which reports as being defined: data Invariant a = Invariant aHowever, whenever a = constructs a new value, it will have the function in the $ field applied to it. As an example: data SortedList a = SortedList (Invariant [a]) deriving (Data,Typeable) toSortedList xs = SortedList $ Invariant sort (sort xs) fromSortedList (SortedList (Invariant _ xs)) = xsAny 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  method is partially implemented - all constructed values will have an undefined value for all fields, regardless of which function is passed to . If you only use  (as Uniplate does) then the  method is sufficient.uniplateThe  data type has a ) instance which reports as being defined: data Trigger a = Trigger aHowever, whenever a  or - constructs a new value, it will have the   field set to . The trigger information is useful to indicate whether any invariants have been broken, and thus need fixing. As an example: data SortedList a = SortedList (Trigger [a]) deriving (Data,Typeable) toSortedList xs = SortedList $ Trigger False $ sort xs fromSortedList (SortedList (Trigger t xs)) = if t then sort xs else xsThis 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 detect when the Data operations have been performed, and resort the list.The ( type is often used in conjunction with , which fixes the invariants. uniplateThe   data type has a  instance which reports having no constructors, as though the type was defined as using the extension EmptyDataDecls:  data Hide aThis type is suitable for defining regions that are avoided by Uniplate traversals. As an example: 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.uniplateDeconstruct a value of type .uniplateConstruct a value of type .uniplateDeconstruct a value of type .uniplateConstruct a value of type .uniplateDeconstruct a value of type .uniplateConstruct a value of type .uniplateDeconstruct a value of type .uniplateConstruct a value of type .   NoneuniplateGHCs foldr/build system, but on all platformsuniplate), but suitable for inlining. Copied from Data.ByteString.Base.uniplate'Perform concatentation of continuationsNone5uniplate8The standard Uniplate class, all operations require this6uniplate"The underlying method in the class uniplate (Add (Val 1) (Neg (Val 2))) = ([Val 1, Neg (Val 2)], \[a,b] -> Add a b) uniplate (Val 1) = ([] , \[] -> Val 1 )7uniplate0The type of replacing all the children of a nodeTaking a value, the function should return all the immediate children of the same type, and a function to replace them.8uniplateGet 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]This method is often combined with a list comprehension, for example: "vals x = [i | Val i <- universe x]9uniplate1Get the direct children of a node. Usually using 8 is more appropriate. children = fst . 6:uniplate;Transform every element in the tree, in a bottom-up manner.7For example, replacing negative literals with literals: negLits = transform f where f (Neg (Lit i)) = Lit (negate i) f x = x;uniplateMonadic variant of :<uniplateRewrite 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 compositionality. Given two single transformations f and g, you can construct f  g2 which performs both rewrites until a fixed point.=uniplateMonadic variant of <>uniplatePerform a transformation on all the immediate children, then combine them back. This operation allows additional information to be passed downwards, and can be used to provide a top-down transformation.?uniplateMonadic variant of >@uniplate"Return all the contexts and holes. propUniverse x = universe x == map fst (contexts x) propId x = all (== x) [b a | (a,b) <- contexts x]AuniplateThe one depth version of @ propChildren x = children x == map fst (holes x) propId x = all (== x) [b a | (a,b) <- holes x]BuniplatePerform a fold-like computation on each value, technically a paramorphism56789:;<=>?@AB75689:;<=>?@ABNone$Iuniplate1Take the type of the method, will crash if calledJuniplate Convert a C2 to a list, assumes the value was created with KKuniplateConvert a list to a CLuniplate Transform a C to a list, and back again, in a structure preserving way. The output and input lists must be equal in length. CDFEGHIJKL CDFEGHIJKLNone.'Runiplate9Children are defined as the top-most items of type to starting at the root. All instances must define S , while T and U are optional.Suniplate)Return all the top most children of type to within from.If  from == to then this function should return the root as the single child.TuniplateLike X! but with more general types. If  from == to then this function does not descend. Therefore, when writing definitions it is highly unlikely that this function should be used in the recursive case. A common pattern is to first match the types using T&, then continue the recursion with X.VuniplateThe standard Uniplate class, all operations require this. All definitions must define W, while X and Y are optional.WuniplateThe underlying method in the class. Taking a value, the function should return all the immediate children 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 uniplate (Val i ) = (Zero , \Zero -> Val i ) uniplate (Neg a ) = (One a , \(One a) -> Neg a ) uniplate (Add a b) = (Two (One a) (One b), \(Two (One a) (One b)) -> Add a b)XuniplatePerform a transformation on all the immediate children, then combine them back. This operation allows additional information to be passed downwards, and can be used to provide a top-down transformation. This function can be defined explicitly, or can be provided by automatically in terms of W.0For 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)YuniplateApplicative variant of XZuniplateGet 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]This method is often combined with a list comprehension, for example: "vals x = [i | Val i <- universe x][uniplate1Get the direct children of a node. Usually using Z is more appropriate.\uniplate;Transform every element in the tree, in a bottom-up manner.7For example, replacing negative literals with literals: negLits = transform f where f (Neg (Lit i)) = Lit (negate i) f x = x]uniplateApplicative variant of \^uniplateRewrite 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 compositionality. Given two single transformations f and g, you can construct f mplus g2 which performs both rewrites until a fixed point._uniplateApplicative variant of ^`uniplate"Return all the contexts and holes. universe x == map fst (contexts x) all (== x) [b a | (a,b) <- contexts x]auniplateThe one depth version of ` children x == map fst (holes x) all (== x) [b a | (a,b) <- holes x]buniplatePerform a fold-like computation on each value, technically a paramorphismduniplate"Return the children of a type. If  to == from7 then it returns the original element (in contrast to [)RUTSVYXWZ[\]^_`abcdefghijNone1uniplateAn existential box representing a type which supports SYB operations.luniplate Wrap up a (a -> a)& transformation function, to use with mmuniplateApply 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]3 is applied in turn, right to left. Within each  [Transformer], the individual  Transformer values may be interleaved.The implementation will attempt to perform fusion, and avoid walking any part of the 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.>klmNone >2WRUSTVYWXZ[\]^_`abcdefghijklmVYXWRUTSZ[\]^_`abcdefghijmklNoneApuniplate9Children are defined as the top-most items of type to starting at the root. All instances must define q , while r and s are optional.quniplate)Return all the top most children of type to within from.If  from == to then this function should return the root as the single child.runiplateLike v! but with more general types. If  from == to then this function does not descend. Therefore, when writing definitions it is highly unlikely that this function should be used in the recursive case. A common pattern is to first match the types using r&, then continue the recursion with v.tuniplateThe standard Uniplate class, all operations require this. All definitions must define u, while v and w are optional.uuniplateThe underlying method in the class. Taking a value, the function should return all the immediate children 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 uniplate (Val i ) = (Zero , \Zero -> Val i ) uniplate (Neg a ) = (One a , \(One a) -> Neg a ) uniplate (Add a b) = (Two (One a) (One b), \(Two (One a) (One b)) -> Add a b)vuniplatePerform a transformation on all the immediate children, then combine them back. This operation allows additional information to be passed downwards, and can be used to provide a top-down transformation. This function can be defined explicitly, or can be provided by automatically in terms of u.0For 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)wuniplateApplicative variant of vxuniplateGet 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]This method is often combined with a list comprehension, for example: "vals x = [i | Val i <- universe x]yuniplate1Get the direct children of a node. Usually using x is more appropriate.zuniplate;Transform every element in the tree, in a bottom-up manner.7For example, replacing negative literals with literals: negLits = transform f where f (Neg (Lit i)) = Lit (negate i) f x = x{uniplateApplicative variant of z|uniplateRewrite 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 z is more appropriate, but | can give better compositionality. Given two single transformations f and g, you can construct f mplus g2 which performs both rewrites until a fixed point.}uniplateApplicative variant of |~uniplate"Return all the contexts and holes. universe x == map fst (contexts x) all (== x) [b a | (a,b) <- contexts x]uniplateThe one depth version of ~ children x == map fst (holes x) all (== x) [b a | (a,b) <- holes x]uniplatePerform a fold-like computation on each value, technically a paramorphismuniplate"Return the children of a type. If  to == from7 then it returns the original element (in contrast to y)psrqtwvuxyz{|}~twvupsrqxyz{|}~None>F(uniplate,The main combinator used to start the chain.0The following rule can be used for optimisation: !plate Ctor |- x == plate (Ctor x)uniplate%The field to the right is the target.uniplate.The field to the right may contain the target.uniplateThe field to the right does not contain the target.uniplate:The field to the right is a list of the type of the targetuniplateThe field to the right is a list of types which may contain the targetuniplate Used for p+ definitions where both types are the same.uniplateWrite an instance in terms of a projection/injection pair. Usually used to define instances for abstract containers such as Map: instance Biplate (Map.Map [Char] Int) Char where biplate = plateProject Map.toList Map.fromListIf the types ensure that no operations will not change the keys we can use the fromDistictAscList! function to reconstruct the Map: instance Biplate (Map.Map [Char] Int) Int where biplate = plateProject Map.toAscList Map.fromDistinctAscList!psqrtwuvxyz{|}~None >Fklmpsqrtwuvxyz{|}~mklNoneH uniplate  gmapT == vuniplateUse y and uniplateUse y and uniplateUse yuniplateUse y and uniplate  gmapM == wuniplate mkT == uniplate everywhere == uniplate  mkM == iduniplate everywhereM == uniplateOnly for use with uniplateUse x or , perhaps followed by a fold.#Not an exact equivalent to the SYB  everything9, as the operators may be applied in different orders.   NoneJuniplate*If you want to keep an existing type classuniplate  composOp == vuniplate  composOpM == wuniplate composOpM_ ==  (return ()) (>>)uniplate composOpMonoid =  mempty mappenduniplate composOpMPlus =  mzero mplusuniplateProbably replace with x , perhaps  None>Nuniplate PlateAll (Map.Map a b) c where plateAll = plateProject Map.toList Map.fromListpsqrtwuvxyz{|}~ NoneQ uniplateZipper structure, whose root type is the first type argument, and whose focus type is the second type argument.uniplate/Create a zipper, focused on the top-left value.uniplateCreate a zipper with a different focus type from the outer type. Will return Nothing if there are no instances of the focus type within the original value.uniplateFrom a zipper take the whole structure, including any modifications.uniplate-Move one step left from the current position.uniplate.Move one step right from the current position.uniplate-Move one step down from the current position.uniplate+Move one step up from the current position.uniplate*Retrieve the current focus of the zipper..uniplate7Replace the value currently at the focus of the zipper.   NoneSuniplate)Return all the top most children of type to within from.If  from == to then this function should return the root as the single child.uniplate"Return the children of a type. If  to == from7 then it returns the original element (in contrast to 9)uniplateUsed for defining instances  UniplateFoo a => UniplateFoo [a]56789:;<=>?@AB  None_/uniplate9The standard Uniplate class, all operations require this.uniplate#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 uniplate (Val i ) = (Zero , \Zero -> Val i ) uniplate (Neg a ) = (One a , \(One a) -> Neg a ) uniplate (Add a b) = (Two (One a) (One b), \(Two (One a) (One b)) -> Add a b)uniplate0The type of replacing all the children of a nodeTaking a value, the function should return all the immediate children of the same type, and a function to replace them.uniplate=Compatibility method, for direct users of the old list-based  functionuniplateGet 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]This method is often combined with a list comprehension, for example: "vals x = [i | Val i <- universe x]uniplate1Get the direct children of a node. Usually using  is more appropriate. children = fst . uniplate;Transform every element in the tree, in a bottom-up manner.7For example, replacing negative literals with literals: negLits = transform f where f (Neg (Lit i)) = Lit (negate i) f x = xuniplateMonadic variant of uniplateRewrite 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 compositionality. Given two single transformations f and g, you can construct f  g2 which performs both rewrites until a fixed point.uniplateMonadic variant of uniplatePerform a transformation on all the immediate children, then combine them back. This operation allows additional information to be passed downwards, and can be used to provide a top-down transformation.uniplateMonadic variant of uniplate"Return all the contexts and holes. propUniverse x = universe x == map fst (contexts x) propId x = all (== x) [b a | (a,b) <- contexts x]uniplateThe one depth version of  propChildren x = children x == map fst (holes x) propId x = all (== x) [b a | (a,b) <- holes x]uniplatePerform a fold-like computation on each value, technically a paramorphismCDEFGHIJKLNoneauniplate)Return all the top most children of type to within from.If  from == to then this function should return the root as the single child.uniplate"Return the children of a type. If  to == from7 then it returns the original element (in contrast to )uniplateUsed for defining instances  UniplateFoo a => UniplateFoo [a]%CDEFGHIJKL NonebAuniplate9Children are defined as the top-most items of type to starting at the root.uniplate.Compatibility method, for direct users of the  function2CDEFGHIJKL None>eQuniplateThis class represents going from the container type to the target.+This class should only be constructed with ,  and uniplate!This function is used to write a  instance from a  oneuniplate,The main combinator used to start the chain.0The following rule can be used for optimisation: !plate Ctor |- x == plate (Ctor x)uniplate.the field to the right may contain the target.uniplateThe field to the right does not contain the target. This can be used as either an optimisation, or more commonly for excluding primitives such as Int.CDEFGHIJKLNonehruniplate,The main combinator used to start the chain.0The following rule can be used for optimisation: !plate Ctor |- x == plate (Ctor x)uniplate%The field to the right is the target.uniplate.The field to the right may contain the target.uniplateThe field to the right does not contain the target.uniplate:The field to the right is a list of the type of the targetuniplateThe field to the right is a list of types which may contain the targetuniplate Used for PlayAll+ definitions where both types are the same.9CDEFGHIJKLNone >i2CDEFGHIJKL  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghHIQRKLMNOPSTUijklmnopqrstuefghHIQRKLMNOPSTUijklmnopvwxyz{|}~tu          v x y }                u t                           H I J  K L M N O P Q R S T Uefijklmnghopvxytvwxyz{|tuq&uniplate-1.6.13-8D6rTtwpH9N398BLFHtiNb%Data.Generics.Uniplate.Data.InstancesData.Generics.UniplateData.Generics.StrData.Generics.Uniplate.DataOnly!Data.Generics.Uniplate.OperationsData.Generics.Uniplate.DirectData.Generics.Uniplate.DataData.Generics.SYBData.Generics.ComposData.Generics.Uniplate.TypeableData.Generics.Uniplate.ZipperData.Generics.UniplateOnData.Generics.UniplateStrData.Generics.UniplateStrOnData.Generics.BiplateData.Generics.PlateTypeableData.Generics.PlateDirectData.Generics.PlateData%Data.Generics.Uniplate.Internal.Utils2Data.Generics.Uniplate.Internal.DataOnlyOperations$Data.Generics.Uniplate.Internal.DataIntSetIntMapSetMap Invariant invariant fromInvariantTriggertrigger fromTriggerHidefromHidefromMaptoMapfromSettoSet fromIntMaptoIntMap fromIntSettoIntSet $fDataHide $fFunctorHide $fShowHide $fDataTrigger$fFunctorTrigger$fDataInvariant$fShowInvariant$fOrdMap$fEqMap $fShowMap$fOrdSet$fEqSet $fShowSet $fOrdIntMap $fEqIntMap $fShowIntMap $fOrdIntSet $fEqIntSet $fShowIntSet $fDataIntSet $fDataIntMap $fDataSet $fDataMap $fReadTrigger $fOrdTrigger $fEqTrigger $fShowTrigger $fReadHide $fOrdHide$fEqHideUniplateuniplate UniplateTypeuniversechildren transform transformMrewriterewriteMdescenddescendMcontextsholesparaStrZeroOneTwostrMapstrMapMstrTypestrListlistStr strStructure$fTraversableStr $fFoldableStr $fFunctorStr$fEqStr $fShowStrBiplatebiplate descendBi descendBiM universeBi childrenBi transformBi transformBiM rewriteBi rewriteBiM contextsBiholesBi Transformer transformer transformBis $fBiplateab $fUniplateaplate|*|+|-||*||+ plateSelf plateProject$fBiplateRatioInteger$fBiplateRatioRatio$fUniplateRatio $fBiplate[][]$fBiplate[]Char $fUniplate[] $fUniplate()$fUniplateFloat$fUniplateDouble$fUniplateInteger$fUniplateChar$fUniplateBool $fUniplateIntgmapTgmapQlgmapQrgmapQgmapQigmapMmkT everywheremkM everywhereMmkQ everythingComposcomposOp composOpM composOpM_composOpMonoid composOpMPlus composOpFoldPlateAllplateAll$fPlateAllRatioto$fPlateAll(,,,,)to$fPlateAll(,,,)to$fPlateAll(,,)to$fPlateAll(,)to$fPlateAllEitherto$fPlateAllMaybeto$fPlateAll[]to$fPlateAll()to$fPlateAllFloatto$fPlateAllDoubleto$fPlateAllIntegerto$fPlateAllCharto$fPlateAllBoolto$fPlateAllInttoZipperzipperzipperBi fromZipperleftrightdownuphole replaceHole$fEqZipN $fEqZipper$fEqZip1 $fEqDiff1 BiplateType universeOn childrenOn transformOn transformOnM rewriteOn rewriteOnM descendOn descendOnMholesOn contextsOnuniplateOnList uniplateList biplateList uniplateAllbase Data.DataDatagfoldlgunfold fromConstrB fromConstrghc-prim GHC.TypesTruetoConstrbuilderinlinePerformIO GHC.IO.UnsafeunsafePerformIO concatContSPEC Unsafe.Coerce unsafeCoerceGHC.BasemplusDataBoxCCCfromCHitMap dataBoxVal dataBoxKeyFollowerIntMap2TypeMap2CacheOracle fromOracleAnswerMissFollowHitfromHitTypeKeyTypeMapTypeSettypeKey!map_findWithDefaultmap_fromAscList map_keysSet map_member set_partition set_toAscList set_unionsuniplateVerbosehitTestcachereadCacheFollowerreadCacheHitMaplookup2insert2 intLookup2 intInsert2followerdataBox sybChildren emptyHitMap insertHitMapfixEq biplateData uniplateData descendData descendBiData descendDataMdescendBiDataMgmapA transformer_ transformBis_ Data.FoldablefoldlfoldrGHC.List!!idData.Typeable.InternalTypeableTyCon Data.TypeabletypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1 rnfTypeReptypeRepFingerprint typeRepTyCon typeRepArgs splitTyConAppmkFunTy funResultTygcast2gcast1gcasteqTcast showsTypeReptypeReptypeOfTypeReprnfTyContyConFingerprint tyConName tyConModule tyConPackage Data.ProxyProxyData.Type.Equality:~:Refl:~~:HRefl