/?i      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghNone+357IN0cThis data type lets you store a "diff", that is a structure tracking the differences, between two 's. This is essentially the result of a  operation tracking all of the changes that would happen in a data structure without actually applying the changes. Traversing over the  of s with i to actually convert the s would then apply the changes.'A monadic function type that keeps the  in a j for you, and instantiates k such that l and m operate on leaves of the . Use T, U, and W to navigate the .If you have read the chapter about zippers in the book "Learn You a Haskell for Great Good", you might appreciate that a zipper is provided for ) in this module, and a number of useful Control.Monad.State#ful APIs are also provided, namely T and U.%Although it should be noted usually, nes, os, s, and  are all you will need. Like  , but pairs the   value with the 0 data type itself. This is used to instantiate p and q, which means in order to use r or iL, it is first necessary to store the tree in this data type along with the  : operator indicating the order in which the leaf objects o will be retrieved. (This data type controls algorithms like  where monadic evaluation needs to occur in a certain order. This simple operation code decides whether evaluation of leaves happens before evaluation of sub-s (C) or whether evaluation of leaves happens after evaluation of sub-s ().will have the Rule ;s evaluated such that the longest branches evaluate first.will have the Rule <s evaluated such that the shortest branches evaluate first.This class provides , which generates a  of type  RoseTrie p o from a data type of type d, similar to how the s class can generate a t from a data structure.This class provides +, which generates a data structure of type d from a  of type  RoseTrie p o, similar to how the u- class can generate a data structure from a t.A  is just a newtype around a pair of two elements forming a node, the first being the leaf of the node, and the second being the branches of the node. The leaf may or may not exist, so it is wrapped in a v data structure.When you associate an object o at a path [p]6, a walk is performed, with each segment of the path [p]B selecting a branch that contains another sub-node. When the path [p]* is empty, the walk stops and the object o% is placed into the current sub-node. The empty .Since  does not directly instantiate w, it cannot be used with the x function. So the newTrie function is provided which behaves similarly. In other words, this function takes a list of transfomration functions that modify a , and starting with an y  RoiseTrie5, applies each transformation in order to build the .*This is a focusing lens that focuses on a  node at a given path [p],, rather than an element at the given path.0Focuses on an individual leaf at the given path.This function merges two trees together, given a leaf-merging function that can optionally create or remove leaves based on whether or not leaves exist on the left and right at any given point in the path [p].Also required are two : functions: a function that can convert the first (left)  parameter to a L of the resultant type, and a function that can convert the second (right)  parameter to a Y of the resultant type. These functions are used for when leaves exist only on the left ., or for when leaves only exist on the right .?The given leaf-merging function is called for every single sub- node where the path [p]' exists in both the overlay and target  s. Each sub- node may or may not have a Leaf.If the  node for the overlay  and the target < are both without leaves, the merging function is passed z0 as both arguments to the updating function. If only the target  has a Leaf, the overlay Leaf as passed with {? as the first (left) argument to the updating function, and z- is passed as the second (right) argument.If only the overlay  has a leaf, zT is passed as the first (left) argument to the merging function, and the overlay Leaf is passed with {# as the second (right) argument.#If both the target and the overlay s have Leafs, both Leafs are passed with { to the merging function.OAlso, it is necessary to specify (as the first parameter to this function) the   type, which indicates  or  evaluation. ^Insert a leaf at a given address, updating it with the combining function if it already exist.!!Insert a leaf at a given address."!Update a leaf at a given address.#Delete a leaf or Branch at a given address.$ Create a # from a list of associationes, the |' element containing the branches, the }F element containing the leaf value. This is the inverse operation of +.%Like $ but called with (~ ).& Create a  with ()Q nodes. This is useful for times when the structure of the tree is all you need.' Create a  containing only a single  to a single element.(This function analogous to the e function, which returns a value stored in a leaf, or nothing if there is no leaf at the given path.)This function works like J, but takes a key predicate to match keys of the tree, rather than using ()$. This means the efficient O(log n)   function in the Data.Map module cannot be used, each key must be inspected one-by-one making this algorithm O(n^2). This also means multiple values may match the given key predicate. Lookups are always performed in j order, this helps improve efficiency a little bit, as the matches nearest the beggining of each list of m are chosen first, and lazily taking only the first few matches will save us from searching the entire tree.!Take note of the different types p and b. This means the path p you use to search the + need not be the same type as the branches b of the 0, and what is returned are the actual branches b that matched the path p, not the path p itself.*This function calls ) and returns only the first result. This can be used to take advantage of Haskell's laziness and save time by halting the search for matching paths as soon as the first match is found.+(Get all items and their associated path.,Like + but restricts the resulting list of associations to only include elements that lie along a given path. This function walks through the tree with the given path, and collects every  along the way. Where there is a leaf, the path is partitioned into the path up to the leaf and the path after the leaf. The list of returned values are these partitioned paths paired with their associated leaves.-Like ,=, but allows you to use a matching function that other than ((). The matching function should return z( for non-matching path elements, and a {S containing a path element that may have been transformed by the matching function..Like -& but uses a monadic matching function./Apply  } to the result of +, behaves just like how   or   works.0;Counts the number of *nodes*, which includes the number of Branches and Leafs. Remember that s that contain  may not necessarily contain  elements.1Counts the number of s only.2/Counts the number of branches only, not leaves.4fSince this function does not merge trees monadically, it is not important whether merging happens in  or  order.LGThis function computes the cartesian of two trees. For example, if the + of two trees are: y-- tree X tree Y [( [a, b, c], t ), [( [b, c], w ), ( [a, b ], u ), ( [a ], x )] ( [b ], v )]  Then the 1 of these two trees X and Y is the evaluation of % on: [( [a, b, c] ++ [b, c], t<>w ), ( [a, b, c] ++ [a ], t<>x ), ( [a, b, ] ++ [b, c], u<>w ), ( [a, b, ] ++ [a, ], u<>x ), ( [b, ] ++ [b, c], v<>w ), ( [b, ] ++ [a ], v<>x )] MLike L but uses < as the function that computes the product of each element.QRun the " function, returning the modified & and the last result returned by the  function.R Analogous to , does the same thing as Q- but disgards the final return value of the  function.S Analogous to , does the same thing as Q but disgards the updated - and only keeps the last return value of the  function.TNGo to the node with the given path. If the path does not exist, it is created.UkGo up one level in the tree, storing the current sub-tree into the upper tree, unless the current tree is Void;, in which case it is deleted from the upper tree. Returns ' if we are already at the root of the  and could not go back.VReturns ( if we are at the top level of the tree.W%Go back to the top level of the tree.XReturn the current path.YhProduce a difference report of two trees with the given comparison predicate. If the predicate returns ,, the node does not appear in the resultant T. If there is a difference, the difference is recored into a node in the resultant .[Call Z2 using 'Prelude.(==)' as the comparison predicate.\Call Z2 using 'Prelude.(==)' as the comparison predicate.i  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh]  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ihgfedc  b !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPa`_^]QRSTUVWXYZ[\\   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh     !"#$%&'()*+,-./012 3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsqrtqruvwxlyzly{l|ly}l~llllvwllllllllllyPlnoroset_Iz9UEk5BrnmD0PBSLK7myeData.Tree.RoseTrieData.Traversable traversalLeafData.MaplookupMapassocselemsData.Array.IArray RoseTrieDiffLeftOnly RightOnlyUpdateRoseTrieUpdateRoseTrieT ZipRoseTrieReduceRoseTriereduceRoseTrieBy getReduced RunRoseTrie DepthFirst BreadthFirstDataToRoseTrie toRoseTrieDataFromRoseTrie fromRoseTrieRoseTrieroseTrieempty newRoseTrieleafbranchesnodepath mergeWithKeyMalteralterM insertWithinsertupdatedelete fromListWithfromList blankRoseTrie singleton slowLookup slowLookup1 partitionspartitionsWithpartitionWithMsize leafCount branchCountnull mergeWithKey mergeWithM mergeWith unionWithKeyM unionWithKey unionWithM unionWithunion unionsWithunionsintersectionWithKeyMintersectionWithKeyintersectionWithMintersectionWith intersectionintersectionsWith intersectionsdifferenceWithKeyMdifferenceWithKeydifferenceWithMdifferenceWith differencedifferencesWith differences productWithproduct zipRoseTriezipperSubRoseTrie zipperHistoryrunUpdateRoseTrieTexecUpdateRoseTrieTevalUpdateRoseTrieTgotobackatTophomegetPath treeDiffWithM treeDiffWith treeDiffMtreeDiff$fMonadTransUpdateRoseTrieT $fMonadStateMaybeUpdateRoseTrieT$fMonadUpdateRoseTrieT$fApplicativeUpdateRoseTrieT$fFunctorUpdateRoseTrieT$fFunctorReduceRoseTrie$fTraversableReduceRoseTrie$fFoldableReduceRoseTrie$fNFDataRoseTrie$fMonoidProduct $fMonoidSum$fFunctorRoseTriebasetraversetrans_GZTjP9K5WFq01xC9BAGQpFControl.Monad.Trans.State.LazyStateTmtl_Aue4leSeVkpKLsfHIV51E8Control.Monad.State.Class MonadStategetputminil_FXhdkB40pORHlEMGn3YSpVData.Lens.MinimalLens Data.FoldablefoldFoldable TraversablefoldrGHC.ShowShowGHC.BaseStringGHC.ReadReadMaybeMonoidnewNothingJust Data.TuplefstsndflipconstGHC.Listghc-prim GHC.Classes==mapmappend execStateT GHC.TypesFalseTrue