h-cfc]       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ K L M N O PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""################################################################################################################################################################################################################# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % & & ' ( ( ( ( ( ( ()0.9.3.3- Safe-InferredAn approximate clone of RIO from the rio package, but not based on ReaderT. The trouble with ReaderT( is that its third type argument has a nominal role, so we can't coerce through it when it's wrapped in some other data type. Ugh.*6 6$*2 2*. .** ** "* (Instances and convenience functions for +,. We use monoidal-containers to take advantage of its better monoid instance. -. has mappend = union, which is left-biased.   has mappend = unionWith mappend instead.None AppendMap is a synonym for /0Pattern synonym for  A synonym for  Deletes a key, returning   if the result is empty.Like  7 but indicates whether the resulting container is empty Displays a   as a tree. See 12 for details. Displays a   as a tree, using the supplied function to convert nodes to string.   Deprecated: Use   instead Deprecated: Use   instead Deprecated: Use   instead3 #A mutable version of  None  A  holds a map of values of type a> and allows low-overhead modifications via IO. Operations on  run in IO.  Create a new  out of an  !Create a new empty "Insert an element into a  at the given key#)Attempt to lookup an element by key in a $4Runs the provided action over the intersection of a  and an  %.Runs the provided action over the values of a &Checks whether a  is empty'Retrieves the size of a ( on the values, thus can't tell if a value has changed or not.5 Produce a   k (Maybe v) by comparing two   k vs, old and new respectively. Just& represents an association present in new and either not present in old! or where the value has changed. Nothing+ represents an association only present in old but no longer present in new@. See also 49 for a similar but weaker version which does not require   on the values but thus can't indicated a value not changing between old and new with Nothing.6Given a   k (Maybe v)% representing keys to insert/update (Just ) or delete (Nothing*), produce a new map from the given input   k v. See also 4. and 46.7Split a   k (Either a b) into Map k a and Map k b, equivalent to .7 id8Given a   k (Maybe v)% representing keys to insert/update (Just ) or delete (Nothing), produce a new   k from the given input set.Equivalent to:  applyMapKeysSet patch (.8 m) == .8 (6 patch m) but avoids the intervening Map and needs no values.68547456787 Deprecated: Use  mapEither instead Safe-Inferred9When inserting an item into a :, a 9 is returned. If the caller retains the ticket, the item is guranteed to stay in memory (and thus in the :=). The ticket can also be used to remove the item from the :3 prematurely (i.e. while it is still alive), using A.:A : holds a set of values of type a, but does not retain them - that is, they can still be garbage-collected. As long as the a values remain alive, the : will continue to refer to them.;#The items referenced by the WeakBag<Insert an item into a :.=Create an empty :.> Create a :+ with one item; equivalent to creating the : with = , then using <.?Visit every node in the given list. If new nodes are appended during the traversal, they will not be visited. Every live node that was in the list when the traversal began will be visited exactly once; however, no guarantee is made about the order of the traversal.ARemove an item from the :6; does nothing if invoked multiple times on the same 9.<The itemThe : to insert into8An arbitrary value to be used in the following callbackA callback to be invoked when the item is removed (whether automatically by the item being garbage collected or manually via A) Returns a 9 that ensures the item is retained and allows the item to be removed. =@?:;9 :9=><@?A;@ Deprecated: Use ? insteadB& is a weak pointer to some value, and C' ensures the value referred to by a B stays live while the ticket is held (live). On GHC or GHCJS when not built with the  fast-weak cabal flag, B. is a wrapper around the simple version of 9: where the key and value are the same. On GHCJS when built with the  fast-weak cabal flag, B( is implemented directly in JS using  h$FastWeak and h$FastWeakTicket/ which are a nonstandard part of the GHCJS RTS.NoneMBA reference to some value which can be garbage collected if there are only weak references to the value left.E? can be used to try and obtain a strong reference to the value.The value in a FastWeak' can also be kept alive by obtaining a C using F) if the value hasn't been collected yet.Synonymous with  .CA B0 which has been promoted to a strong reference. D; can be used to get the referred to value without fear of Nothing, and H% can be used to get the weak version.D Return the a kept alive by the given C.This needs to be in IO so we know that we've relinquished the ticket.EGet the value referred to by a B& if it hasn't yet been collected, or Nothing if it has been collected.FTry to create a C for the given B> which will ensure the value referred remains alive. Returns Just if the value hasn't been collected and a ticket can therefore be obtained, Nothing if it's been collected.G Create a C# directly from a value, creating a B, in the process which can be obtained with D.This function is marked NOINLINE so it is opaque to GHC. If we do not do this, then GHC will sometimes fuse the constructor away so any weak references that are attached to the ticket will have their finalizer run. Using the opaque constructor, GHC does not see the constructor application, so it behaves like an IORef and cannot be fused away.The result is also evaluated to WHNF, since forcing a thunk invalidates the weak pointer to it in some cases.H Demote a C); which ensures the value is alive, to a B: which doesn't. Note that unless the ticket for the same B is held in some other way the value might be collected immediately.I%A weak reference that is always emptyIFDHEGBCCBGDHEFI This module defines the FunctorMaybe class, which extends Functors with the ability to delete values.None9J=A class for values that combines filtering and mapping using   . Morally, J ~ KleisliFunctor  .K(Combined mapping and filtering function.JKJKJ Deprecated: Use   from Data.Witherable insteadL;. .M;+ +N;( (O;! !This module contains the Reflex interface, as well as a variety of convenience functions for working with ms, ls, and other signals. Trustworthy +,12YBPAn P6 type can be built by accumulating occurrences of an m.YEfficiently select an m keyed on  9. This is more efficient than manually filtering by key.^ Retrieve the m% for the given key. The type of the m is determined by the type of the key, so this can be used to fan-out m s whose sub-ms have different types.Using _ s and the  primitive is far more efficient than (but equivalent to) using  0 to select only the relevant occurrences of an m._An _ allows you to efficiently a an m based on a key. This is much more efficient than filtering for each key with  .a Retrieve the m% for the given key. The type of the m is determined by the type of the key, so this can be used to fan-out m s whose sub-ms have different types.Using _ s and the  primitive is far more efficient than (but equivalent to) using  0 to select only the relevant occurrences of an m.bb' designates monads that can create new l s based on ms; usually this will be p or a monad based on it. b> is required to create any stateful computations with Reflex.c Create a new l whose value will initially be equal to the given value and will be updated whenever the given m9 occurs. The update takes effect immediately after the m* occurs; if the occurrence that sets the l> (or one that is simultaneous with it) is used to sample the l, it will see the old value of the l, not the new one.d Create a n value using the given initial value that changes every time the m occurs.e Create an o value using the given initial value that changes every time the m occurs.g Create a new m that only occurs only once, on the first occurrence of the supplied m.hAn event which only occurs at the current moment in time, such that: 5coincidence (pushAlways (\a -> (a <$) <$> now) e) = eii9 designates monads that can read the current value of a l. This includes both q and p.jGet the current value in the lkThe k class contains all the primitive functionality needed for Functional Reactive Programming (FRP). The t type parameter indicates which "timeline" is in use. Timelines are fully-independent FRP contexts, and the type of the timeline determines the FRP engine to be used. For most purposes, the <= implementation is recommended.l4A container for a value that can change over time. ls can be sampled at will, but it is not possible to be notified when they changem5A stream of occurrences. During any given frame, an m is either occurring or not occurring; if it is occurring, it will contain a value of the given type (its "occurrence type")nA container for a value that can change over time and allows notifications on changes. Basically a combination of a l and an m, with a rule that the l! will change if and only if the m fires.oAn o is a more general form of a n. Instead of always fully replacing the value, only parts of it can be patched. This is only needed for performance critical code via ( to make small changes to large values.p=A monad for doing complex push-based calculations efficientlyq=A monad for doing complex pull-based calculations efficientlyrAn m with no occurrencess Create a l that always has the given valuet Create an m from another m$; the provided function can sample l s and hold ms, and use the results to produce a occurring (Just) or non-occurring (Nothing) resultuLike t but intended for functions that the implementation can consider cheap to compute for performance considerations. WARNING: The function passed to u/ may be run multiple times without any caching.v Create a l by reading from other l;s; the result will be recomputed whenever any of the read l s changesw,Merge a collection of events; the resulting m will only occur if at least one input event is occurring, and will contain all of the input keys that are occurring simultaneouslyxEfficiently fan-out an event to many destinations. You should save the result in a let-binding, and then repeatedly ^& on the result to create child eventsy Create an m8 that will occur whenever the currently-selected input m occursz Create an m that will occur whenever the input event is occurring -- and its occurrence value, another m/, is also occurring. You maybe looking for ' switchHold never ' instead.{ Extract the l of a n.| Extract the m of the n.} Create a new n . The given q9 must always return the most recent firing of the given m , if any.~ Create a new o . The given PullM's value must always change in the same way that the accumulated application of patches would change that value.1Create a merge whose parents can change over timeExperimental: Create a merge whose parents can change over time; changing the key of an Event is more efficient than with mergeIncremental Extract the l component of an o Extract the m component of an o Convert an o to a n Construct a   for a l given an   for its occurrence type Construct a   for an m given an   for its occurrence type Construct a   for a n given an   for its occurrence type Construct a   for an o given  (s for its patch target and patch types.Efficiently fan-out an event to many destinations. You should save the result in a let-binding, and then repeatedly a& on the result to create child eventsConstructs a single m out of a map of events. The output event may fire with multiple keys simultaneously. Coerce a l2 between representationally-equivalent value types Coerce an m7 between representationally-equivalent occurrence types Coerce a n2 between representationally-equivalent value types Coerce an o2 between representationally-equivalent value types Construct a n from a l and an m. The l must change when and only when the m fires, such that the  Behavior'9s value is always equal to the most recent firing of the m*; if this is not the case, the resulting n# will behave nondeterministically. Construct a n value that never changesAccumulate an o with the supplied initial value and the firings of the provided m3, using the combining function to produce a patch. Similar to $ but the combining function runs in p Similar to  but allows filtering of updates (by dropping updates when the combining function produces Nothing) Similar to $ but the combining function runs in pAccumulate an o by folding occurrences of an m with a function that both accumulates and produces a value to fire as an m:. Returns both the accumulated value and the constructed m.Like $ but the combining function runs in pAccumulate an o by folding occurrences of an m with a function that both optionally accumulates and optionally produces a value to fire as a separate output m. Note that because  +s are discarded in both cases, the output m! may fire even though the output o" has not changed, and the output o! may update even when the output m is not firing.Like ! but the combining function is a p action"A somewhat slow implementation of g Create an m from another m%. The provided function can sample l s and hold ms.Flipped version of  .Rotated version of  .Rotated version of  . Alias for  Flipped version of  .*Filter 'f a' using the provided predicate.Filter  s from 'f (Either a b)' into a.Filter  s from 'f (Either a b)' into b.%Replace each occurrence value of the m with the value of the l at the time of that occurrence.%Replace each occurrence value of the m with the value of the l at that time; if it is  +, fire with the contained value; if it is  , drop the occurrence. Create a new m' that combines occurrences of supplied m with the current value of the l. Create a new m that occurs when the supplied m7 occurs by combining it with the current value of the l. Create a new m= by combining each occurrence with the current value of the l. The occurrence is discarded if the combining function returns Nothing Create a new m> that occurs on all but the first occurrence of the supplied m.Create a tuple of two ms with the first one occurring only the first time the supplied m occurs and the second occurring on all but the first occurrence.Take the streak of occurrences starting at the current time for which the event returns  .>Starting at the current time, fire all the occurrences of the m( for which the given predicate returns  . When first   is returned, do not fire, and permanently stop firing, even if  + values would have been encountered later.Take the streak of occurrences starting at the current time for which the event returns 'Just b'.>Starting at the current time, fire all the occurrences of the m> for which the given predicate returns 'Just b'. When first   is returned, do not fire, and permanently stop firing, even if 'Just b' values would have been encountered later.Drop the streak of occurrences starting at the current time for which the event returns  .Starting at the current time, do not fire all the occurrences of the m( for which the given predicate returns  . When   is first returned, do fire, and permanently continue firing, even if  + values would have been encountered later.Both take and drop the streak of occurrences starting at the current time for which the event returns 'Just b'.For the left event, starting at the current time, fire all the occurrences of the m7 for which the given function returns 'Just b'. When   is returned, do not fire, and permanently stop firing, even if 'Just b' values would have been encountered later.For the right event, do not fire until the first occurrence where the given function returns  , and fire that one and all subsequent occurrences. Even if the function would have again returned 'Just b', keep on firing.Split the supplied m into two individual ms occurring at the same time with the respective values from the tuple.Print the supplied   and the value of the m" on each occurrence. This should only be used for debugging.Note: As with Debug.Trace.trace, the message will only be printed if the m is actually used.Print the output of the supplied function on each occurrence of the m. This should only be used for debugging.Note: As with Debug.Trace.trace, the message will only be printed if the m is actually used. Create a new m$ that occurs if at least one of the ms in the list occurs. If multiple occur at the same time they are folded from the left with the given function. Create a new m$ that occurs if at least one of the ms in the list occurs. If multiple occur at the same time the value is the value of the leftmost event. Create a new m$ that occurs if at least one of the m:s in the list occurs and has a list of the values of all ms occurring at that time. Create a new m combining the map of m s into an m that occurs if at least one of them occurs and has a map of values of all ms occurring at that time.Like  but for  .1Create a merge whose parents can change over time1Create a merge whose parents can change over timeExperimental: Create a merge whose parents can change over time; changing the key of an Event is more efficient than with mergeIncremental)Split the event into separate events for   and   values.)Split the event into separate events for   and   values, allowing them to fire simultaneously when the input value is  .Split the event into an _4 that allows efficient selection of the individual ms.Switches to the new event whenever it receives one. Only the old event is considered the moment a new one is switched in; the output event will fire at that moment only if the old event does.Because the simultaneous firing case is irrelevant, this function imposes laxer "timing requirements" on the overall circuit, avoiding many potential cyclic dependency / metastability failures. It's also more performant. Use this rather than  and  unless you are absolutely sure you need to act on the new event in the coincidental case.Switches to the new event whenever it receives one. Whenever a new event is provided, if it is firing, its value will be the resulting event's value; if it is not firing, but the old one is, the old one's value will be used., by always forwarding the old event the moment it is switched out, avoids many potential cyclic dependency problems / metastability problems. It's also more performant. Use it instead unless you are sure you cannot.switches to a new event whenever it receives one. At the moment of switching, the old event will be ignored if it fires, and the new one will be used if it fires; this is the opposite of y%, which will use only the old value., by always forwarding the old event the moment it is switched out, avoids many potential cyclic dependency problems / metastability problems. It's also more performant. Use it instead unless you are sure you cannot.When the given outer event fires, condense the inner events into the contained patch. Non-firing inner events will be replaced with deletions.See See Given a   of events (e.g., a   with m values) and an event of   es (e.g., a   with m values), produce an m of the  ) type that fires with the patched value. Create a new m" that only occurs if the supplied m occurs and the l# is true at the time of occurrence.Create a new behavior given a starting behavior and switch to the behavior carried by the event when it fires. Combine two n b -> c -> d b1 :: Behavior t a b2 :: Behavior t b e :: Event t cthen we can do: "f <$> b1 <*> b2 <@> e :: Event t din order to apply the function f to the relevant values.(The alternative would be something like: attachWith (\(x1, x2) y -> f x1 x2 y) ((,) <$> b1 <*> b2) e :: Event t dor a variation involing a custom data type to hold the combination of l8s even when that combination might only ever be used by f.#A more suggestive example might be: handleMouse <$> bPlayerState <*> bMousePosition <@> eMouseClick :: Event t (GameState -> GameState)An version of $ that does not use the value of the m.Alternatively, it is  in operator form.>This is useful when we want to combine the values of several l(s at particular points in time using an   style syntax. If we have: g :: a -> b -> d b1 :: Behavior t a b2 :: Behavior t b e :: Event t cwhere e- is firing at the points in time of interest.Then we can use : "g <$> b1 <*> b2 <@ e :: Event t dto combine the values of b1 and b25 at each of those points of time, with the function g" being used to combine the values.This is the same as  except that the m) is being used only to act as a trigger.A "cheap" version of . See the performance note on u.A "cheap" version of  . See the performance note on u. An alias for A "cheap" version of . See the performance note on u.A "cheap" version of . See the performance note on u.A "cheap" version of  . See the performance note on u.A "cheap" version of . See the performance note on u.,Merge a collection of events; the resulting m will only occur if at least one input event is occurring, and will contain all of the input keys that are occurring simultaneously1Create a merge whose parents can change over timeExperimental: Create a merge whose parents can change over time; changing the key of an Event is more efficient than with mergeIncrementalA "cheap" version of . See the performance note on u.A "cheap" version of . See the performance note on u. A "cheap" version of  . See the performance note on u.See See Never:   = r.m' intersection (convenient interface to z).m< intersection. Only occurs when both events are co-incident.Left-biased event union (prefers left event on simultaneous occurrence). >?@ABCDEFG   PQRSTUVWX_`a\]^YZ[bfgcdehijklnmoqpzs{xwrvtuy}~|J klnmoqpzs{xwrvtuy}~|ijbfgcdeh_`a\]^YZ[PQRSTUVWXJ  Deprecated: Use  instead. The 'switchHold*' naming convention was chosen because those functions are more closely related to each other than they are to y.  Deprecated: Use  instead. The 'switchHold*' naming convention was chosen because those functions are more closely related to each other than they are to y. +H 6H <H :H %H #H )H %H 7H :H $H *H ,H 'H $H %H #H 0H 1H 7H =H (H ;H *H ?H 'H (H .H 2H 6H H H 4H 8H 3H 7H H H 4H 8H 8H -H 0H /  Safe-Inferred efficiently collects m values using  and combines them via   to provide an m result.I <  Safe-Inferred1 efficiently collects n values using , and combines them monoidally to provide a n result.Type synonym for  Deprecated: Use  insteadJ  NoneA n whose | m- will never fire with the same value as the {  Behavior's contents. In order to maintain this constraint, the value inside a  is always evaluated to  .https://wiki.haskell.org/Weak_head_normal_formweak head normal form. Internally,  uses pointer equality as a heuristic to avoid unnecessary update propagation; this is much more efficient than performing full comparisons. However, when the # is converted back into a regular n!, a full comparison is performed. Construct a ) by eliminating redundant updates from a n.Retrieve a normal n from a <. This will perform a final check using the output type's  , instance to ensure deterministic behavior.#WARNING: If used with a type whose   instance is not law-abiding - specifically, if there are cases where x /= x,  may eliminate more |: occurrences than it should. For example, NaN values of   and  - are considered unequal to themselves by the   instance, but can be equal by pointer equality. This may cause " to lose changes from NaN to NaN.Create a UniqDynamic without uniqing it on creation. This will be slightly faster than uniqDynamic when used with a Dynamic whose values are always (or nearly always) different from its previous values; if used with a Dynamic whose values do not change frequently, it may be much slower than uniqDynamicK +K 1K -K 3 8This module contains various functions for working with n values. n+ and its primitives have been moved to the k class.None +,239 ) Poor man's Generics for product types only.Indicates that all elements in a type-level list are applications of the same functor.This class allows s and FHlists to be built from regular lists; they must be contiguous and sorted..A typed index into a typed heterogeneous list.Like +, but with a functor wrapping each element.A heterogeneous list whose type and length are fixed statically. This is reproduced from the  package due to integration issues, and because very little other functionality from that library is needed.2Represents a time changing value together with an _2 that can efficiently detect when the underlying n has a particular value. This is useful for representing data like the current selection of a long list. Semantically, %demuxed (demux d) k === fmap (== k) dHowever, when 1 is used multiple times, the complexity is only  O(log(n)), rather than O(n) for fmap.Map a sampling function over a n.Flipped version of  Create a new n; that only signals changes if the values actually changed. Create a new n' that changes only when the underlying n) changes and the given function returns  - when given both the old and the new values. Dynamic Maybe that can only update from Nothing to Just or Just to Just (i.e., cannot revert to Nothing) Create a n& that accumulates values from another n+. This function does not force its input n until the output n is forced.Like , but the the accumulator function may decline to update the result Dynamic's value. Create a n6 using the initial value and change it each time the m occurs using a folding function on the previous value and the value of the m.Like ", but the combining function is a p action, so it can j existing  Behaviors and c new ones. Create a n using the provided initial value and change it each time the provided m= occurs, using a function to combine the old value with the Event'"s value. If the function returns  =, the value is not changed; this is distinct from returning   the old value, since the Dynamic's | m will fire in the  ! case, and will not fire in the   case.Like ", but the combining function is a p action, so it can j existing  Behaviors and c new ones. Create a new n$ that counts the occurrences of the m. Create a new n> using the initial value that flips its value every time the m occurs.Switches to the new m whenever it receives one. Only the old event is considered the moment a new one is switched in; the output event will fire at that moment if only if the old event does.Prefer this to  where possible. The lack of doing double work when the outer and (new) inner fires means this imposes fewer "timing requirements" and thus is far more easy to use without introducing fresh failure cases.  is also more performant.Switches to the new m. whenever it receives one. Switching occurs before the inner m fires - so if the n changes and both the old and new inner Events fire simultaneously, the output will fire with the value of the new m.Prefer  to this where possible. The timing requirements that switching before imposes are likely to bring down your app unless you are very careful.  is also more performant.Split a n pair into a pair of ns Convert a   with n elements into a n of a   with non-n elements. Convert an   with n elements into a n of an   with non-n elements.Convert a list with n elements into a n of a list with non-n0 elements, preserving the order of the elements. Combine a n of a   of n s into a n! with the current values of the n s in a map. Combine a n of an   of n s into a n! with the current values of the n s in a map.Print the value of the n when it is first read and on each subsequent change that is observed (as 3), prefixed with the provided string. This should only be used for debugging.Note: Just like Debug.Trace.trace, the value will only be shown if something else in the system is depending on it.Print the result of applying the provided function to the value of the n when it is first read and on each subsequent change that is observed (as ). This should only be used for debugging.Note: Just like Debug.Trace.trace, the value will only be shown if something else in the system is depending on it.Replace the value of the m with the current value of the n each time the m occurs.Note: tagPromptlyDyn d e differs from tag (current d) e in the case that e" is firing at the same time that d is changing. With tagPromptlyDyn d e, the new value of d will replace the value of e, whereas with tag (current d) e, the old value will be used, since the l won't be updated until the end of the frame. Additionally, this means that the output m/ may not be used to directly change the input n8, because that would mean its value depends on itself.  When creating cyclic data flows, generally tag (current d) e is preferred. Attach the current value of the n to the value of the m each time it occurs.Note: attachPromptlyDyn d is not the same as attach (current d). See  for details.!Combine the current value of the n with the value of the m each time it occurs.Note: attachPromptlyDynWith f d is not the same as attachWith f (current d). See  for details. Create a new m by combining the value at each occurrence with the current value of the n value and possibly filtering if the combining function returns  .Note: attachPromptlyDynWithMaybe f d is not the same as attachWithMaybe f (current d). See  for details. Factor a Dynamic t (Maybe a) into a Dynamic t (Maybe (Dynamic t a)), such that the outer n is updated only when the Maybe's constructor chages from   to  3 or vice-versa. Whenever the constructor becomes   , an inner n/ will be provided, whose value will track the a inside the  ; when the constructor becomes  , the existing inner n will become constant, and will not change when the outer constructor changes back to  .Turns a 'Dynamic t (Either a b)' into a 'Dynamic t (Either (Dynamic t a) (Dynamic t b))' such that the outer n is updated only when the  ! constructor changes (e.g., from   to  ).!Factor a 'Dynamic t DSum' into a n   containing nested n values. The outer n" updates only when the key of the  ) changes, while the update of the inner n+ represents updates within the current key. Demultiplex an input value to a  with many outputs. At any given time, whichever output is indicated by the given n will be  ."Select a particular output of the ; this is equivalent to (but much faster than) mapping over the original n4 and checking whether it is equal to the given key.5Collect a hetereogeneous list whose elements are all ns into a single n whose value represents the current values of all of the input ns.8Convert a datastructure whose constituent parts are all ns into a single n whose value represents all the current values of the input's constituent ns.>dn{|>n{|d Deprecated: Use  instead L L L L L =L  L 9L L $L L L%L$None +, This type represents an occurrence of unqDyn before it has been processed by qDyn. If you see it in a type error, it probably means that unqDyn has been used outside of a qDyn context.Quote a n9 expression. Within the quoted expression, you can use $(unqDyn [| x |]) to refer to any expression x of type  Dynamic t a'; the unquoted result will be of type a Antiquote a n expression. This can only be used inside of a qDyn quotation. Create a n value using other ns as inputs. The result is sometimes more concise and readable than the equivalent  !-based expression. For example: +[mkDyn| $x + $v * $t + 1/2 * $a * $t ^ 2 |]would have a very cumbersome   encoding.This module defines the  class Safe-Inferred1 efficiently collects l values using , and combines them monoidally to provide a l result.Type synonym for  Deprecated: Use  insteadM A class for actions that can be "adjusted" over time based on some m: such that, when observed after the firing of any such m, the result is as though the action was originally run with the ms value.None 1 Synonym for A   that supports adjustment over time. After an action has been run, if the given events fire, it will adjust itself so that its net effect is as though it had originally been run with the new value. Note that there is some issue here with persistent side-effects: obviously, IO (and some other side-effects) cannot be undone, so it is up to the instance implementer to determine what the best meaning for this class is in such cases. Traverse a   of - actions, running each of them. The provided m of patches to the  # can add, remove, or update values. Traverses a   of - actions, running each of them. The provided m of patches to the  / can add, remove, update, move, or swap values. Traverses a  , running the provided  action. The provided m of patches to the  0 can add, remove, update, move, or swap values.N   Deprecated: Use Adjustable insteadO 6 Safe-Inferred +,0. designates monads that can run reflex frames.Propagate some events firings and read the values of events afterwards.This function will create a new frame to fire the given events. It will then update all dependent events and behaviors. After that is done, the given callback is executed which allows to read the final values of events and check whether they have fired in this frame or not.5All events that are given are fired at the same time.This function is typically used in the main loop of a reflex framework implementation. The main loop waits for external events to happen (such as keyboard input or a mouse click) and then fires the corresponding events using this function. The read callback can be used to read output events and perform a corresponding response action to the external event.&Run a frame without any events firing.2This function should be used when you want to use j and c when no events are currently firing. Using this function in that case can improve performance, since the implementation can assume that no events are firing when j or c are called.This function is commonly used to set up the basic event network when the application starts up.A monad where new events feed from external sources can be created.Creates a root m, (one that is not based on any other event).When a subscriber first subscribes to an event (building another event that depends on the subscription) the given callback function is run and passed a trigger. The callback function can then set up the event source in IO. After this is done, the callback function must return an accompanying teardown action.Any time between setup and teardown the trigger can be used to fire the event, by passing it to .Note: An event may be set up multiple times. So after the teardown action is executed, the event may still be set up again in the future.)Monad that allows to read events' values.Read the value of an m from an  (created by calling ).After event propagation is done, all events can be in two states: either they are firing with some value or they are not firing. In the former case, this function returns Just act, where act in an action to read the current value of the event. In the latter case, the function returns Nothing.4This function is normally used in the calllback for .Monad in which Events can be  subscribed. This forces all underlying event sources to be initialized, so that the event will fire whenever it ought to. Events must be subscribed before they are read using readEvent.Subscribe to an event and set it up if needed. This function will create a new  from an m$. This handle may then be used via  in the read callback of .If the event wasn't subscribed to before (either manually or through a dependent event or behavior) then this function will cause the event and all dependencies of this event to be set up. For example, if the event was created by &, then it's callback will be executed./It's safe to call this function multiple times.Framework implementation support class for the reflex implementation represented by t.Like !, but without reading any events./Create a new event and store its trigger in an IORef while it's active.An event is only active between the set up (when it's first subscribed to) and the teardown phases (when noboby is subscribing the event anymore). This function returns an Event and an IORef'. As long as the event is active, the IORef will contain   the event trigger to trigger this event. When the event is not active, the IORef will contain  . This allows event sources to be more efficient, since they don't need to produce events when nobody is listening.$Fire the given trigger if it is not  .$Fire the given trigger if it is not  , and read from the given .P P P P P P P P P P P P P P P P P >P P ?P P  Safe-Inferred 3. represents an action that is notified via an m when it has finished executing. Note that the specific definition of "finished" is determined by the instance of , but the intent is to allow ls and ns to be safely sampled, regardless of where they were created, when the post-build m fires. The post-build m- will fire exactly once for an given action.Retrieve the post-build m for this action.Q' ':Q$ $3Q! !4None *.Create a set of widgets based on the provided  . When the input m/ fires, remove widgets for keys with the value  ( and add/replace widgets for keys with   values.Display the given map of items (in key order) using the builder function provided, and update it with the given event.  = update entries will delete the corresponding children, and   entries will create them if they do not exist or send an update event to them if they do.Create a dynamically-changing set of Event-valued widgets. This is like $, specialized for widgets returning  Event t a.  would return Dynamic t (Map k (Event t a)) in this scenario, but  flattens this to Event t (Map k a) via y.Create a dynamically-changing set of widgets, one of which is selected at any time.Like : but discards the value of the list item widget's output m.Create a dynamically-changing set of widgets from a Dynamic key/value map. Unlike the withKey variants, the child widgets are insensitive to which key they're associated with.Create a dynamically-changing set of widgets from a Dynamic list.Current selection keyDynamic key/value mapFunction to create a widget for a given key from Dynamic value and Dynamic Bool indicating if this widget is currently selectedEvent that fires when any child's return Event fires. Contains key of an arbitrary firing widget.Current selection keyDynamic key/value mapFunction to create a widget for a given key from Dynamic value and Dynamic Bool indicating if this widget is currently selectedEvent that fires when any child's return Event fires. Contains key of an arbitrary firing widget.This module provides a pure implementation of Reflex, which is intended to serve as a reference for the semantics of the Reflex class. All implementations of Reflex should produce the same results as this implementation, although performance and laziness/strictness may differ.None 25A completely pure-functional k6 timeline, identifying moments in time with the type t.The   instance of t must be dense: for all x :: t, there must not exist any y :: t such that   x < y < x. The  < instance will be used exclusively to memoize functions of t(, not for any of its other capabilities. lnmo lmnoR R 'R "R (R $R6 67A class that ties together queries to some data source and their results, providing methods for requesting data from the source and accumulating streamed results.None :A class that allows sending of s and retrieval of s. See  for a commonly used interface.This type can be used to track of the frequency of interest in a given . See note on QueryMorphism's must be group homomorphisms when acting on the query type and compatible with the query relationship when acting on the query result.A  can be thought of as a declaration of interest in some set of data. A < is the set of data associated with that interest set. The crop; function provides a way to determine what part of a given  is relevant to a given .Apply a  to a Map a  to a SSSSSS Safe-Inferred  >A % action can trigger requests of type  Request m a based on m!s, and receive responses of type  Response m a in return. Note that the a type can vary within the  action, but will be linked for a given request. For example, if  Request m is   and  Response m is  , then  has the same type as T.The type of requests that this  can emit The type of responses that this  can receive"Emit a request whenever the given m/ fires, and return responses in the resulting m."Emit a request whenever the given m! fires, and ignore all responses."Emit a request whenever the given m: fires, and unwrap the responses before returning them.  Response m must be  .U; ;8U5 53U/ /4 Safe-Inferredm$ represents actions that can create ms that can be triggered by   actions.Create a triggerable m=. Whenever the resulting function is called, the resulting m will fire at some point in the future. Note that this may not be synchronous.Like , but the callback itself takes another callback, to be invoked once the requested m occurrence has finished firing. This allows synchronous operation.Like , but with setup and teardown. This relatively complex type signature allows any external listeners to be subscribed lazily and then removed whenever the returned m is no longer being listened to. Note that the setup/teardown may happen multiple times, and there is no guarantee that the teardown will be executed promptly, or even at all, in the case of program termination.V4 47V/ /V* *9V% %: Safe-Inferred = represents actions that can trigger other actions based on ms.The type of action to be triggered; this is often not the same type as the triggering action.*Perform the action contained in the given m whenever the m' fires. Return the result in another m. Note that the output m, will generally occur later than the input m , since most % actions cannot be performed during m propagation.Like , but do not return the result. May have slightly better performance.Like , but the resulting m! occurs only when the callback ( a -> IO ()3) is called, not when the included action finishes.NOTE: Despite the name,  does not run its action in a separate thread - although the action is free to invoke forkIO and then call the callback whenever it is ready. This will work properly, even in GHCJS (which fully implements concurrency even though JavaScript does not have built in concurrency).W 7W< <:None  <&A basic implementation of .A reference to an  suitable for firing with .A value with which to fire an m, as well as a callback to invoke after its propagation has completed.Run a # action. The argument should be a   into which s can be passed; it is expected that some other thread will be responsible for popping values out of the   and firing their s.Retrieve the current  :; event trigger invocations pushed into it will be fired.  X X X <X :X >X X 4X X X :X> >X9 96X5 5&X, ,X,,!X,#,(X,*,2X,4,;X,=,X,,X,,X,,X,,1Clocks, timers, and other time-related functions.None :<=>?q'Metadata associated with a timer "tick";Amount of time that has elapsed in the current tick period.NB: The provided lag function must *actually* delay the event.The length of a tick intervalThe basis time from which intervals count and with which the initial calculation of elapsed time will be made.Event that starts a tick generation thread. Usually you want this to be something like the result of getPostBuild that only fires once. But there could be uses for starting multiple timer threads.Event that starts a tick generation thread. Usually you want this to be something like the result of  that only fires once. But there could be uses for starting multiple timer threads.Poisson event rate (Hz)Baseline time for eventsEvent that starts a tick generation thread. Usually you want this to be something like the result of getPostBuild that only fires once. But there could be uses for starting multiple timer threads. Start sending events in response to the event parameter.Poisson event rate (Hz)Baseline time for eventsY 2Y 5Y YYY#Y%-Y/:Y<YY YYY#Y%-Y/:Y<YY5 5Y55Y55None +,697A basic implementation of .We use a hack here to pretend we have x ~ request a; we don't want to use a GADT, because GADTs (even with zero-size existential contexts) can't be newtypes WARNING: This type should never be exposed. In particular, this is extremely unsound if a MyTag from one run of runRequesterT is ever compared against a MyTag from anotherRuns in reverse to accommodate for the fact that we accumulate it in reverse with its arguments flippedRun a  action. The resulting m will fire whenever requests are made, and responses should be provided in the input m. The   keys will be used to return the responses to the same place the requests were issued.2Map a function over the request and response of a Matches incoming responses with previously-sent requests and uses the provided request "decoder" function to process incoming responses.$The function to map over the request%The function to map over the response The internal + whose input and output will be transformedThe resulting Given a request (from ), produces the wire format of the request and a function used to process the associated responseThe outgoing requests4The incoming responses, tagged by an identifying keyA map of outgoing wire-format requests and an event of responses keyed by the ' key of the associated outgoing requestGiven a request (from ), produces the wire format of the request and a function used to process the associated responseThe outgoing requests9A map of incoming responses, tagged by an identifying keyA map of outgoing wire-format requests and an event of responses keyed by the ' key of the associated outgoing request*Z  Z $Z Z $Z Z Z  Z Z Z Z Z Z Z 2Z 4Z Z Z Z Z Z Z!Z#(Z*2Z4;Z=Z!ZZZZZZZZ'+Z-/Z14Z6:ZZZZ[NoneNone 3#Provides a basic implementation of .Run a  action. An m should be provided that fires immediately after the action is finished running; no other ms should fire first. Deprecated\ 7\ \ =\ 1\ =\ \ =\ 7\ ;\ =\ 3\ \ \22\33\44 \55\66\77\88\99\::\;;\<<None +,29 #Provides a basic implementation of !. Note that, despite the name,  is not an instance of  .+A function that fires events for the given 3s and then runs any followup actions provided via  . The given  action will be run once for the initial trigger execution as well as once for each followup.Run a  action, returning a $ that allows the caller to trigger ms while ensuring that * actions are run at the appropriate time.] ] ] ] ;] ] ] ] ]]]]]]]]???]>><]==]<<>None 3A basic implementation of . -WARNING: Do not construct this directly; use   insteadRun a  action.Given a function like & for the underlying monad, implement  for ?. This is necessary when the underlying monad doesn't have a & instance or to override the default  behavior. Like  , but for sequenceIntMapWithAdjust.Like  , but for .$Map a function over the output of a .+Change the monad underlying an EventWriterT!^ ^ ^ 7^ ^ ^ ^ ^ 5^ ?^ ^ ;^ ^ ;^ ^ ;^ ?^ ^^^ ^^^^^^^^^^ ^^^ None 59<withQueryT's QueryMorphism argument needs to be a group homomorphism in order to behave correctlyMaps a function over a % that can change the underlying monaddynWithQueryT's (Dynamic t QueryMorphism) argument needs to be a group homomorphism at all times in order to behave correctly  _ _ =_ 5_ _ _ 8_ _ /_ ;_ ;_ _ 5_ 1_ _ !_ _? ?_??!_?#?(_?*?8_?:?_??_??_??_??_??__>`None  None +,9]A basic implementation of .Run a  action. The dynamic writer output will be provided along with the result of the action.$Map a function over the output of a .When the execution of a  action is adjusted using , the n6 output of that action will also be updated to match.a a a =a a 9a ?a =a a a a a a a 7aaa aaaaaaaaaaabNone! Implementation of BehaviorWriterNone +,9A basic implementation of .Run a  action. The behavior writer output will be provided along with the result of the action.$Map a function over the output of a .c c c >c c >c c c c c c c 8c99c::c;; c<<c==c>>c??ccccccc"None  de f 8f f f? ?3f; ;<f7 7;f3 39f/ /5f+ +>f' '2#None +,1259<The monad for actions that manipulate a Spider timeline identified by x is the old name for &The default, global Spider environment.Designates the default, global Spider timeline&Retrieve the current SpiderTimelineEnvStores all global data relevant to a particular Spider timeline; only one value should exist for each type xA statically allocated   Construct an  # equivalent to that constructed by  , but with no caching; if the computation function is very cheap, this is (much) more efficient than  'A subscriber that never triggers other  s =Subscribe to an Event only for the duration of one occurrence  Construct an  ; whose value is guaranteed not to be recomputed repeatedlyTODO: Try a caching strategy where we subscribe directly to the parent when there's only one subscriber, and then build our own FastWeakBag only when a second subscriber joins *Propagate everything at the current height *Propagate everything at the current height &Run an event action outside of a frame Create a new SpiderTimelineEnv *Pass a new timeline to the given function. Run an action affecting the global Spider timeline; this will be guarded by a mutex for that timeline Run an action affecting a given Spider timeline; this will be guarded by a mutex for that timeline             Deprecated: Use  instead g # g  g ! g & g  g  g . g  g " g 2 g . g 4 g 0 g 5 g  g  g  g > g " g  g  g  g  g  g > g  g  g  g  g  g 5 g  g < g  g  g  g 4 g ' g ! g " g  g  g  g ' g , g & g 9 g # g  g  g  g  g  g  g  g  g  g  g  g; g g g g  g! g#+ g-4 g6 g g g g g  g! g#+ g-4 g6 g g g g g g g g g g g g  g! g#* g,4 g6 g7; g= g g g g  g g g g  g! g#( g*1 g3; g= g g g g ghThis module exports all of the user-facing functionality of the  Reflex engineNone   $(This module contains an instance of the k: class that provides profiling/cost-center information.None 259 l n m o  % i  i $ i  i  i 0 i  i 9 i 8 i  i . i  i  i  i  i  i  i  i  i  i , i  i  i  i  i 1 i  i! i#( i*2 i4 i i  i i i i i%This module provides combinators for building FRP graphs/networks and modifying them dynamically.None A n "network": Takes a n of network-creating actions and replaces the network whenever the n updates. The returned Event of network results fires at post-build time and when the n" updates. Note: Often, the type a is an Event, in which case the return value is an Event-of-Events, where the outer m) fires when switching networks. Such an m# would typically be flattened (via ). "Given an initial "network" and an m of network-creating actions, create a network that is recreated whenever the Event fires. The returned Dynamic of network results occurs when the Event does. Note: Often, the type a is an Event, in which case the return value is a Dynamic-of-Events that would typically be flattened (via switchPromptlyDyn). Render a placeholder network to be shown while another network is not yet done building  <None     PQRSTUVWXl n m _`a\]^YZ[o bfgcdehijqpklnmoqpzs{xwrvtuy}~|J  &None  1 Run a headless FRP network. Inside the action, you will most probably use the capabilities provided by the  and  type classes to interface the FRP network with the outside world. Useful for testing. Each headless network runs on its own spider timeline. The action to be run in the headless FRP network. The FRP network is closed at the first occurrence of the resulting m.  'Noneh Build sortable content in such a way that re-sorting it can cause minimal disruption to an existing context.Naively re-sorting a list of images would destroy every image and add them back in the new order. This framework is able to avoid that by preserving the identity of each image and simply moving it to the new location.Example: let sortByFst = buttonA $> comparing fst sortBySnd = buttonB $> comparing snd sortEvent = leftmost [sortByFst, sortBySnd] sortableList (\k v -> text $ "\n" ++ show k ++ " " ++ v) -- show each element on a new line (Map.fromList $ zip [0..] [(3, "a"), (2, "b"), (1, "c")]) sortEvent 6Function to render the content for each key/value pair=The sortable list with an initial ordering determined by the Map keys in ascending order.An event carrying a sort function for the list  (Provides a convenient way to describe a series of interrelated widgets that can send data to, invoke, and replace one another. Useful for modeling user interface "workflows."None  A widget in a workflow When the m returned by a   fires, the current  * is replaced by the one inside the firing m. A series of  "s must share the same return type. Runs a   and returns the n result of the   (i.e., a n& of the value produced by the current   node, and whose update m fires whenever one   is replaced by another).  Similar to  , but outputs an m8 that fires at post-build time and whenever the current   is replaced by the next  . Map a function over a  $, possibly changing the return type. Map a "cheap" function over a  !. Refer to the documentation for u5 for more information and performance considerations.   jkljkmjknjkojkpjkqjrsjrsjrstjrujrvjrwjrxyz{|||}~2      <ABCG>?@DEF                                                                                   NT                                 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""e"d""""""""""######################=########################################################################################################################################################################################## # # # # # # # ### # # ### # # # # # # # # # # # # # # #### # # # # # # # # # # # # # # # # # # # ## # ## ## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # # # ######## # # # # # # # # # # # # # # # # # # # # # # # # # # # ## # # # # # # # # # ## # # # # # # # # # # ## ## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ## # # # ###### # # # # # # # # # # #### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $$$% % % & & ' ( ( ( ( ( ( ( /0 /0  /{ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /8 / / / / / / / / / / / / /7 / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /0 5 .   :  yz            j  j  j      j j j j j j j j j j j j j j j j jr j j j j j j4 j4 j4 j4 j4 j4 j j  j  j  j  j  j  j  j  j                   $ $ $ $ $ $ $ $ reflex-0.9.3.3-inplace Reflex.ClassData.FastMutableIntMapControl.Monad.ReaderIOData.AppendMapData.FastWeakBag Data.Map.Misc Data.WeakBagReflex.FastWeakReflex.FunctorMaybeReflex.EventWriter.ClassReflex.DynamicWriter.ClassReflex.Dynamic.UniqReflex.DynamicReflex.Dynamic.THReflex.BehaviorWriter.ClassReflex.Adjustable.ClassReflex.Host.ClassReflex.PostBuild.ClassReflex.Collection Reflex.PureReflex.Query.ClassReflex.Requester.ClassReflex.TriggerEvent.ClassReflex.PerformEvent.ClassReflex.TriggerEvent.Base Reflex.TimeReflex.Requester.Base.InternalReflex.PostBuild.BaseReflex.PerformEvent.BaseReflex.EventWriter.BaseReflex.Query.BaseReflex.DynamicWriter.BaseReflex.BehaviorWriter.BaseReflex.NotReady.ClassReflex.Spider.InternalReflex.ProfiledReflex.NetworkReflex.Host.HeadlessReflex.Widget.BasicReflex.Workflowreflexsrc/Control/Monad/ReaderIO.hsData.MapMonoidalDataMapData.Map.Monoidal MonoidalMap Data.Map.LazyshowTreesrc/Data/AppendMap.hs Data.PatchIntMap MapWithMove mapEitherkeysSetSystem.Mem.WeakWeaksrc/Reflex/FunctorMaybe.hsReflexSpider$dmaccum $dmaccumM $dmaccumMaybe$dmhold $dmholdDyn$dmholdIncremental $dmmapAccum $dmmapAccumM$dmmapAccumMaybe$dmnowsrc/Reflex/Class.hssrc/Reflex/EventWriter/Class.hs!src/Reflex/DynamicWriter/Class.hssrc/Reflex/Dynamic/Uniq.hssrc/Reflex/Dynamic.hs"src/Reflex/BehaviorWriter/Class.hs $dmtraverseDMapWithKeyWithAdjustsrc/Reflex/Adjustable/Class.hssrc/Reflex/Host/Class.hssrc/Reflex/PostBuild/Class.hssrc/Reflex/Pure.hssrc/Reflex/Query/Class.hs performEventsrc/Reflex/Requester/Class.hs src/Reflex/TriggerEvent/Class.hs src/Reflex/PerformEvent/Class.hssrc/Reflex/TriggerEvent/Base.hssrc/Reflex/Time.hs%src/Reflex/Requester/Base/Internal.hsReflex.Requester.Basesrc/Reflex/PostBuild/Base.hssrc/Reflex/PerformEvent/Base.hssrc/Reflex/EventWriter/Base.hssrc/Reflex/Query/Base.hsReflex.EventWriter src/Reflex/DynamicWriter/Base.hsReflex.DynamicWriter!src/Reflex/BehaviorWriter/Base.hs $dmnotReady$dmnotReadyUntilsrc/Reflex/NotReady/Class.hssrc/Reflex/Spider/Internal.hs Reflex.Spidersrc/Reflex/Profiled.hspatch-0.0.8.4-da606124867fffef4aed125edf686bd64d31e45d659467a7a4a2285961e8ea4eData.Functor.Misc EitherTagLeftTagRightTag dmapToThese eitherToDSum dsumToEitherData.Patch.IntMap PatchIntMap unPatchIntMaptraverseIntMapPatchWithKeypatchIntMapNewElementspatchIntMapNewElementsMap getDeletionswitherable-0.5-c1fff0ed85ce02bd7adcbffcd13f184d939cc647336577b82ef5a62f57618aa3 WitherablemapMaybeReaderIO runReaderIO$fMonadReadereReaderIO$fMonadIOReaderIO$fMonadFixReaderIO$fMonadReaderIO$fApplicativeReaderIO$fFunctorReaderIO AppendMap _unAppendMapnonEmptyDeletemapMaybeNoNull showTreeWith$fDefaultMonoidalMapFastMutableIntMapnewnewEmptyinsertlookupforIntersectionWithImmutable_for_isEmptysizegetFrozenAndClear applyPatchtoListFastWeakBagTicket FastWeakBag_weakBag_childrenempty traverse_traverseremove diffMapNoEqdiffMapapplyMapmapPartitionEithersapplyMapKeysSet WeakBagTicketWeakBag singletonFastWeakFastWeakTicketgetFastWeakTicketValuegetFastWeakValuegetFastWeakTicketmkFastWeakTicketgetFastWeakTicketWeak emptyFastWeak FunctorMaybe fmapMaybe$fFunctorMaybeIntMap$fFunctorMaybeMap$fFunctorMaybeList$fFunctorMaybeMaybe AccumulatoraccumaccumM accumMaybe accumMaybeMmapAccum mapAccumM mapAccumMaybemapAccumMaybeMEventSelectorInt selectIntEventSelectorGselectG EventSelectorselect MonadHoldholdholdDynholdIncremental buildDynamicheadEnow MonadSamplesampleBehaviorEventDynamic IncrementalPushMPullMneverconstantpush pushCheappullmergeGfanGswitch coincidencecurrentupdatedunsafeBuildDynamicunsafeBuildIncrementalmergeIncrementalGmergeIncrementalWithMoveGcurrentIncrementalupdatedIncrementalincrementalToDynamicbehaviorCoercion eventCoerciondynamicCoercionincrementalCoercionmergeIntIncrementalfanIntfanmergeIntcoerceBehavior coerceEvent coerceDynamiccoerceIncremental unsafeDynamicconstDynaccumIncrementalaccumMIncrementalaccumMaybeIncrementalaccumMaybeMIncrementalmapAccumIncrementalmapAccumMIncrementalmapAccumMaybeIncrementalmapAccumMaybeMIncremental slowHeadE pushAlwaysfforffor2ffor3 fforMaybeffilter filterLeft filterRighttagtagMaybeattach attachWithattachWithMaybetailE headTailE takeWhileEtakeWhileJustE dropWhileEtakeDropWhileJustEsplitE traceEventtraceEventWith mergeWithleftmost mergeListunsafeMapIncrementalmergeMap mergeIntMapmergeMapIncrementalmergeIntMapIncrementalmergeMapIncrementalWithMove fanEitherfanThesefanMap switchHoldswitchHoldPromptlyswitchHoldPromptOnlycoincidencePatchMapcoincidencePatchIntMapcoincidencePatchMapWithMoveswitchHoldPromptOnlyIncrementalgateswitcherzipDyn zipDynWithdistributeDMapOverDynPuredistributeDMapOverDynPureGdistributeListOverDyndistributeListOverDynWith differencealignEventWithMaybefilterEventKey factorEventaccumDyn accumMDyn accumMaybeDynaccumMaybeMDyn mapAccumDyn mapAccumMDynmapAccumMaybeDynmapAccumMaybeMDynaccumBaccumMB accumMaybeB accumMaybeMB mapAccumB mapAccumMBmapAccumMaybeBmapAccumMaybeMB mapAccum_mapAccumMaybe_ mapAccumM_mapAccumMaybeM_zipListWithEventnumberOccurrencesnumberOccurrencesFromnumberOccurrencesFrom_<@><@pushAlwaysCheap mapMaybeCheapfmapMaybeCheapfforMaybeCheap fforCheap fmapCheaptagCheapmergemergeIncrementalmergeIncrementalWithMovemergeWithCheapmergeWithCheap'switchPromptlyswitchPromptOnly$fMonoidDynamic$fSemigroupDynamic$fIsStringDynamic $fUnzipEvent $fZipEvent$fSemialignEvent $fAlignEvent $fMonoidEvent$fSemigroupEvent $fPlusEvent$fFilterableEvent$fFunctorMaybeEvent$fFunctorEvent $fBindEvent $fApplyEvent $fAltEvent $fNumDynamic $fNumBehavior$fMonoidBehavior$fSemigroupBehavior$fMonadBehavior$fIsStringBehavior$fFunctorBehavior$fFractionalBehavior$fBindBehavior$fApplyBehavior$fApplicativeBehavior$fMonadHoldktContT$fMonadSamplektContT$fMonadHoldktRWST$fMonadSamplektRWST$fMonadHoldktExceptT$fMonadSamplektExceptT$fMonadHoldktStateT$fMonadSamplektStateT$fMonadHoldktWriterT$fMonadSamplektWriterT$fMonadHoldktReaderT$fMonadSamplektReaderT$fDefaultDynamic$fAccumulatorktEvent$fAccumulatorktBehavior$fAccumulatorktDynamic EventWriter tellEvent$fEventWritertwReaderT DynamicWritertellDynMonadDynamicWriter$fDynamicWritertwReaderT UniqDynamic uniqDynamicfromUniqDynamicalreadyUniqDynamic$fMonadUniqDynamic$fApplicativeUniqDynamic$fFunctorUniqDynamic$fAccumulatorTYPEtUniqDynamicIsHList HListElemstoHList fromHListAllAreFunctors FunctorListtoFHList fromFHListRebuildSortedHListrebuildSortedFHListrebuildSortedHListHListPtrHHeadPtrHTailPtrFHListFHNilFHConsHListHNilHConsDemuxmapDynMforDynM holdUniqDyn holdUniqDynByimprovingMaybescanDyn scanDynMaybefoldDynfoldDynM foldDynMaybe foldDynMaybeMcounttoggle switchDynswitchPromptlyDyn splitDynPuredistributeMapOverDynPuredistributeIntMapOverDynPuredistributeListOverDynPurejoinDynThroughMapjoinDynThroughIntMaptraceDyn traceDynWithtagPromptlyDynattachPromptlyDynattachPromptlyDynWithattachPromptlyDynWithMaybemaybeDyn eitherDyn factorDyndemuxdemuxeddistributeFHListOverDynPurecollectDynPure $fHBuild'lFUN$fHBuild'lHList$fGComparekHListPtr$fGEqkHListPtr$fRebuildSortedHList:$fRebuildSortedHList[]$fAllAreFunctorsaf:$fAllAreFunctorsaf[]$fIsHListTuple6$fIsHListTuple4$fIsHListTuple2 $fOrdHListPtr $fEqHListPtrqDynPureunqDyn mkDynPureBehaviorWriter tellBehaviorMonadBehaviorWriter$fBehaviorWritertwReaderT MonadAdjust AdjustablerunWithReplacetraverseIntMapWithKeyWithAdjusttraverseDMapWithKeyWithAdjust%traverseDMapWithKeyWithAdjustWithMovesequenceDMapWithAdjustsequenceDMapWithAdjustWithMovemapMapWithAdjustWithMove$fAdjustabletReaderTMonadReflexHost ReadPhasefireEventsAndRead runHostFrameMonadReflexCreateTriggernewEventWithTriggernewFanEventWithTriggerMonadReadEvent readEventMonadSubscribeEventsubscribeEvent ReflexHost EventTrigger EventHandle HostFrame fireEventsnewEventWithTriggerRef fireEventReffireEventRefAndRead$fMonadSubscribeEventtRWST$fMonadReflexCreateTriggertRWST$fMonadSubscribeEventtExceptT"$fMonadReflexCreateTriggertExceptT$fMonadSubscribeEventtContT $fMonadReflexCreateTriggertContT$fMonadSubscribeEventtStateT!$fMonadReflexCreateTriggertStateT$fMonadSubscribeEventtStateT0"$fMonadReflexCreateTriggertStateT0$fMonadSubscribeEventtWriterT"$fMonadReflexCreateTriggertWriterT$fMonadSubscribeEventtReaderT"$fMonadReflexCreateTriggertReaderT$fMonadReflexHosttRWST$fMonadReflexHosttExceptT$fMonadReflexHosttContT$fMonadReflexHosttStateT$fMonadReflexHosttStateT0$fMonadReflexHosttWriterT$fMonadReflexHosttReaderT PostBuild getPostBuild$fPostBuildtStateT$fPostBuildtStateT0$fPostBuildtReaderTlistHoldWithKey listWithKeylistWithKeyShallowDifflistViewWithKeyselectViewListWithKeyselectViewListWithKey_list simpleListPure unBehaviorunEvent unDynamic unIncremental$fMonadHoldTYPEPureFUN$fMonadSampleTYPEPureFUN$fMonadDynamic$fApplicativeDynamic$fFunctorDynamic$fReflexTYPEPure MonadQuerytellQueryIncrementalaskQueryResultqueryIncremental SelectedCountunSelectedCount QueryMorphism_queryMorphism_mapQueryResult_queryMorphism_mapQueryQuery QueryResultcropmapQuerymapQueryResultcombineSelectedCounts tellQueryDynqueryDynsubQuery $fQueryAp $fQueryVoid $fQueryUnit $fQueryTuple2$fQueryMonoidalMap$fCategoryTYPEQueryMorphism$fCommutativeSelectedCount$fGroupSelectedCount$fMonoidSelectedCount$fSemigroupSelectedCount$fMonadQuerytqReaderT$fEqSelectedCount$fOrdSelectedCount$fShowSelectedCount$fReadSelectedCount$fIntegralSelectedCount$fNumSelectedCount$fBoundedSelectedCount$fEnumSelectedCount$fRealSelectedCount$fIxSelectedCount$fBitsSelectedCount$fFiniteBitsSelectedCount$fStorableSelectedCount$fDataSelectedCount RequesterRequestResponse requesting requesting_requestingIdentitywithRequesting$fRequestertStateT$fRequestertStateT0$fRequestertReaderT TriggerEventnewTriggerEventnewTriggerEventWithOnComplete%newEventWithLazyTriggerWithOnComplete$fTriggerEventtMaybeT$fTriggerEventtStateT$fTriggerEventtStateT0$fTriggerEventtReaderT PerformEvent Performable performEvent_performEventAsync$fPerformEventtMaybeT$fPerformEventtReaderT TriggerEventTunTriggerEventTEventTriggerRefunEventTriggerRefTriggerInvocationrunTriggerEventT askEvents$fSemigroupTriggerEventT$fMonoidTriggerEventT$fAdjustabletTriggerEventT$fMonadHoldTYPEtTriggerEventT$fMonadSampleTYPEtTriggerEventT$fMonadAtomicRefTriggerEventT$fMonadRefTriggerEventT$fTriggerEventtTriggerEventT($fMonadReflexCreateTriggertTriggerEventT$fPostBuildtTriggerEventT$fPerformEventtTriggerEventT$fPrimMonadTriggerEventT$fMonadTransTriggerEventT$fFunctorTriggerEventT$fApplicativeTriggerEventT$fMonadTriggerEventT$fMonadFixTriggerEventT$fMonadIOTriggerEventT$fMonadExceptionTriggerEventT"$fMonadAsyncExceptionTriggerEventT$fMonadCatchTriggerEventT$fMonadThrowTriggerEventT$fMonadMaskTriggerEventTThrottleBufferThrottleBuffer_EmptyThrottleBuffer_Full ThrottleStateThrottleState_ImmediateThrottleState_BufferedTickInfo_tickInfo_alreadyElapsed _tickInfo_n_tickInfo_lastUTC tickLossytickLossyFromPostBuildTime tickLossyFromtickLossyFrom' clockLossygetCurrentTickdelaypoissonLossyFrom poissonLossyinhomogeneousPoissonFrominhomogeneousPoissondebouncebatchOccurrencesthrottlethrottleBatchWithLag$fMonoidThrottleBuffer$fSemigroupThrottleBuffer$fEqThrottleState$fOrdThrottleState$fShowThrottleState$fFunctorThrottleState$fFoldableThrottleState$fTraversableThrottleState$fGenericThrottleState$fDataThrottleState$fEqThrottleBuffer$fOrdThrottleBuffer$fShowThrottleBuffer$fFunctorThrottleBuffer$fFoldableThrottleBuffer$fTraversableThrottleBuffer$fGenericThrottleBuffer$fDataThrottleBuffer $fEqTickInfo $fOrdTickInfo$fShowTickInfotickInfo_alreadyElapsedtickInfo_lastUTC tickInfo_nDecoder RequesterT unRequesterTRequesterState_requesterState_requests_requesterState_nextMyTag MyTagWrapMyTagEntryunEntryMulti2Contents_multi2Contents_values_multi2Contents_dict EntryContentsMyTagTypeOffsetmyTagTypeOffsetMulti3Multi2MultiSingle MyTagTypeMyTagType_SingleMyTagType_MultiMyTagType_Multi2MyTagType_Multi3RequesterDataKeyRequesterDataKey_SingleRequesterDataKey_MultiRequesterDataKey_Multi2RequesterDataKey_Multi3 RequesterDataTagMapemptyRequesterDatasingletonRequesterDatamergeRequesterData mergeTagMaprequesterDataToListsingletonTagMap tagMapToListtraverseTagMapWithKeytraverseRequesterDataforRequesterData myKeyType singleEntry multiEntry unMultiEntry castMyTagWrap runRequesterTwithRequesterT tagRequestresponseFromTag requesting'runWithReplaceRequesterTWith-traverseIntMapWithKeyWithAdjustRequesterTWith+traverseDMapWithKeyWithAdjustRequesterTWithmatchResponsesWithRequestsmatchResponseMapWithRequests$fMyTagTypeOffsetMulti3$fMyTagTypeOffsetMulti2$fMyTagTypeOffsetMulti$fMyTagTypeOffsetSingle$fGCompareTYPEMyTag$fGEqTYPEMyTag$fGCompareTYPEMyTagWrap$fGEqTYPEMyTagWrap$fAdjustabletRequesterT$fMonadReaderrRequesterT%$fMonadReflexCreateTriggertRequesterT$fMonadRefRequesterT$fPerformEventtRequesterT$fMFunctorTYPERequesterT$fMonadTransRequesterT$fRequestertRequesterT$fSemigroupRequesterT$fMonoidRequesterT$fPrimMonadRequesterT$fEventWritertwRequesterT$fFunctorRequesterT$fApplicativeRequesterT$fMonadRequesterT$fMonadFixRequesterT$fMonadIORequesterT$fMonadExceptionRequesterT$fMonadAsyncExceptionRequesterT$fMonadCatchRequesterT$fMonadThrowRequesterT$fMonadMaskRequesterT$fShowMyTagWrap $fEqMyTagWrap$fOrdMyTagWrap$fEnumMyTagWrap $fShowMyTag $fEqMyTag $fOrdMyTag $fEnumMyTag$fTriggerEventtRequesterT$fPostBuildtRequesterT$fMonadHoldTYPEtRequesterT$fMonadSampleTYPEtRequesterT PostBuildT unPostBuildT runPostBuildTmapIntMapWithAdjustImplmapDMapWithAdjustImpl$fMonadTransControlPostBuildT$fAdjustabletPostBuildT$fMonadAtomicRefPostBuildT$fMonadRefPostBuildT$fTriggerEventtPostBuildT%$fMonadReflexCreateTriggertPostBuildT$fPerformEventtPostBuildT$fMonadHoldTYPEtPostBuildT$fMonadSampleTYPEtPostBuildT$fPostBuildtPostBuildT$fPrimMonadPostBuildT$fSemigroupPostBuildT$fMonoidPostBuildT$fFunctorPostBuildT$fApplicativePostBuildT$fMonadPostBuildT$fMonadFixPostBuildT$fMonadIOPostBuildT$fMonadTransPostBuildT$fMonadExceptionPostBuildT$fMonadAsyncExceptionPostBuildT$fMonadMaskPostBuildT$fMonadThrowPostBuildT$fMonadCatchPostBuildT PerformEventTunPerformEventT FireCommandrunFireCommandhostPerformEventT$fMonadAtomicRefPerformEventT$fMonadRefPerformEventT$fMonadHoldTYPEtPerformEventT$fMonadSampleTYPEtPerformEventT($fMonadReflexCreateTriggertPerformEventT$fAdjustabletPerformEventT$fPerformEventtPerformEventT$fPrimMonadPerformEventT$fMonadMaskPerformEventT$fMonadThrowPerformEventT$fMonadCatchPerformEventT$fSemigroupPerformEventT$fMonoidPerformEventT$fMonadExceptionPerformEventT$fMonadIOPerformEventT$fMonadFixPerformEventT$fMonadPerformEventT$fApplicativePerformEventT$fFunctorPerformEventT EventWriterTunEventWriterTrunEventWriterTrunWithReplaceEventWriterTWith&sequenceDMapWithAdjustEventWriterTWithwithEventWriterTmapEventWriterT$fGCompareTYPETellId$fGEqTYPETellId$fPrimMonadEventWriterT$fDynamicWritertwEventWriterT$fMonadQuerytqEventWriterT'$fMonadReflexCreateTriggertEventWriterT$fMonadAtomicRefEventWriterT$fMonadRefEventWriterT$fMonadReaderrEventWriterT$fTriggerEventtEventWriterT$fPostBuildtEventWriterT$fPerformEventtEventWriterT$fRequestertEventWriterT$fAdjustabletEventWriterT$fMonadHoldTYPEtEventWriterT$fMonadSampleTYPEtEventWriterT$fEventWritertwEventWriterT$fFunctorEventWriterT$fApplicativeEventWriterT$fMonadEventWriterT$fMonadTransEventWriterT$fMFunctorTYPEEventWriterT$fMonadFixEventWriterT$fMonadIOEventWriterT$fMonadExceptionEventWriterT!$fMonadAsyncExceptionEventWriterT$fMonadMaskEventWriterT$fMonadCatchEventWriterT$fMonadThrowEventWriterT $fShowTellId $fEqTellId $fOrdTellId $fEnumTellIdQueryTunQueryT runQueryT withQueryT mapQueryT dynWithQueryT$fDynamicWritertwQueryT$fEventWritertwQueryT$fRequestertQueryT$fMonadQuerytqQueryT$fSemigroupQueryT$fMonoidQueryT!$fMonadReflexCreateTriggertQueryT$fMonadRefQueryT$fPerformEventtQueryT$fTriggerEventtQueryT$fMonadAsyncExceptionQueryT$fPostBuildtQueryT$fPrimMonadQueryT$fMFunctorTYPEQueryT$fMonadTransQueryT$fAdjustabletQueryT$fFunctorQueryT$fApplicativeQueryT $fMonadQueryT$fMonadExceptionQueryT$fMonadFixQueryT$fMonadIOQueryT$fMonadAtomicRefQueryT$fMonadCatchQueryT$fMonadThrowQueryT$fMonadMaskQueryT$fMonadSampleTYPEtQueryT$fMonadHoldTYPEtQueryTDynamicWriterTunDynamicWriterTrunDynamicWriterTwithDynamicWriterT$fEventWritertwDynamicWriterT$fMonadQuerytqDynamicWriterT$fRequestertDynamicWriterT$fAdjustabletDynamicWriterT$fPrimMonadDynamicWriterT$fMonadStatesDynamicWriterT$fPostBuildtDynamicWriterT$fTriggerEventtDynamicWriterT$fPerformEventtDynamicWriterT$fMonadReaderrDynamicWriterT$fDynamicWritertwDynamicWriterT)$fMonadReflexCreateTriggertDynamicWriterT$fMonadAtomicRefDynamicWriterT$fMonadRefDynamicWriterT$fFunctorDynamicWriterT$fApplicativeDynamicWriterT$fMonadDynamicWriterT$fMonadTransDynamicWriterT$fMFunctorTYPEDynamicWriterT$fMonadIODynamicWriterT$fMonadFixDynamicWriterT#$fMonadAsyncExceptionDynamicWriterT$fMonadExceptionDynamicWriterT$fMonadCatchDynamicWriterT$fMonadThrowDynamicWriterT$fMonadMaskDynamicWriterT $fMonadSampleTYPEtDynamicWriterT$fMonadHoldTYPEtDynamicWriterTBehaviorWriterTunBehaviorWriterTrunBehaviorWriterTwithBehaviorWriterT$fAdjustabletBehaviorWriterT$fMonadQuerytqBehaviorWriterT$fRequestertBehaviorWriterT$fMonadStatesBehaviorWriterT$fPostBuildtBehaviorWriterT$fTriggerEventtBehaviorWriterT$fPerformEventtBehaviorWriterT$fMonadReaderrBehaviorWriterT!$fBehaviorWritertwBehaviorWriterT*$fMonadReflexCreateTriggertBehaviorWriterT$fMonadAtomicRefBehaviorWriterT$fMonadRefBehaviorWriterT$fFunctorBehaviorWriterT$fApplicativeBehaviorWriterT$fMonadBehaviorWriterT$fMonadTransBehaviorWriterT$fMFunctorTYPEBehaviorWriterT$fMonadIOBehaviorWriterT$fMonadFixBehaviorWriterT$$fMonadAsyncExceptionBehaviorWriterT$fMonadExceptionBehaviorWriterT$fMonadCatchBehaviorWriterT$fMonadThrowBehaviorWriterT$fMonadMaskBehaviorWriterT!$fMonadSampleTYPEtBehaviorWriterT$fMonadHoldTYPEtBehaviorWriterTNotReady notReadyUntilnotReady$fNotReadytTriggerEventT$fNotReadytRequesterT$fNotReadytPerformEventT$fNotReadytQueryT$fNotReadytBehaviorWriterT$fNotReadytDynamicWriterT$fNotReadytEventWriterT$fNotReadytPostBuildT$fNotReadytWriterT$fNotReadytReaderTSpiderHostFramerunSpiderHostFrame SpiderHost unSpiderHostSpiderEventHandlespiderEventHandleValuespiderEventHandleSubscription RootTrigger SpiderPushMComputeM SpiderPullMLocalSpiderTimeline SpiderEnvSpiderTimelineSomeSwitchSubscribedHeightunHeightMerge_merge_accumRef _merge_sub_merge_heightRef_merge_heightBagRef_merge_parentsRefMergeDestroyFunc MergeInitFuncMergeGetSubscriptionMergeUpdateFuncFanInt_fanInt_occRef_fanInt_subscriptionRef_fanInt_subscribersSomeResetCoincidenceEventLoopExceptionCanTraceWeakListSomeAssignment RootClearIntClearClearResultMDynunDynDynType UnsafeDynBuildDynHoldDyn CoincidencecoincidenceSubscribedcoincidenceParentCoincidenceSubscribedcoincidenceSubscribedWeakSelf coincidenceSubscribedInnerParent coincidenceSubscribedOuterParentcoincidenceSubscribedOutercoincidenceSubscribedHeight coincidenceSubscribedSubscriberscoincidenceSubscribedOccurrence%coincidenceSubscribedCachedSubscribedSwitchswitchSubscribed switchParentSwitchSubscribedswitchSubscribedWeakSelfswitchSubscribedCurrentParentswitchSubscribedParentswitchSubscribedBehaviorParents"switchSubscribedOwnWeakInvalidatorswitchSubscribedOwnInvalidatorswitchSubscribedSubscribersswitchSubscribedHeightswitchSubscribedOccurrence switchSubscribedCachedSubscribedFan fanSubscribed fanParent FanSubscribedfanSubscribedParentfanSubscribedSubscribersfanSubscribedOccurrencefanSubscribedCachedSubscribedFanSubscribedChildren_fanSubscribedChildren_weakSelf_fanSubscribedChildren_self_fanSubscribedChildren_list HeightBag_heightBag_contents_heightBag_sizeMergeSubscribedParentWithMove"_mergeSubscribedParentWithMove_key+_mergeSubscribedParentWithMove_subscriptionMergeSubscribedParentunMergeSubscribedParentEventMunEventM SomeMergeInitunSomeMergeInitSomeMergeUpdate"_someMergeUpdate_recalculateHeight!_someMergeUpdate_invalidateHeight_someMergeUpdate_update SomeDynInit SomeHoldInitRootrootInitrootSubscribedrootOccurrenceRootSubscribedrootSubscribedWeakSelfrootSubscribedUninitrootSubscribedOccurrencerootSubscribedSubscribersrootSubscribedCachedSubscribedrootSubscribedKey InvalidatorInvalidatorPullInvalidatorSwitchPull pullCompute pullValuePullSubscribedpullSubscribedParentspullSubscribedOwnInvalidatorpullSubscribedInvalidatorspullSubscribedValueSomeBehaviorSubscribedBehaviorSubscribedBehaviorSubscribedHoldBehaviorSubscribedPull BehaviorM unBehaviorM BehaviorEnvHasSpiderTimelinespiderTimelineHasCurrentHeightgetCurrentHeight scheduleMergeDefergetDeferralQueueEventEnveventEnvDelayedMergeseventEnvResetCoincidenceseventEnvCurrentHeighteventEnvRootClearseventEnvIntClearseventEnvClearseventEnvMergeInitseventEnvMergeUpdateseventEnvDynInitseventEnvHoldInitseventEnvAssignmentsSpiderTimelineEnv'SpiderTimelineEnv_spiderTimeline_eventEnv_spiderTimeline_lockSTEunSTEGlobalHold holdParent holdEventholdInvalidators holdValuedynamicUpdateddynamicCurrentDynamicSreadBehaviorTrackedEventSubscribedeventSubscribedRetainedeventSubscribedHeightRef SubscribersubscriberRecalculateHeightsubscriberInvalidateHeightsubscriberPropagateCacheSubscribed_cacheSubscribed_occurrence_cacheSubscribed_parent_cacheSubscribed_subscribersEventSubscription_eventSubscription_subscribed_eventSubscription_unsubscribeSpiderBehaviorunSpiderBehavior SpiderEvent unSpiderEvent SpiderDynamicunSpiderDynamicSpiderIncrementalunSpiderIncremental debugStrLndebugPropagatedebugInvalidateHeightdebugInvalidate showNodeId showNodeId' unsubscribesubscribeAndReadterminalSubscribersubscribeAndReadHeadnowSpiderEventM cacheEventcacheSubscription subscribewrap eventRootsubscribeAndReadNever eventNevereventFan eventSwitcheventCoincidence eventHoldeventDynsubscribeCoincidenceInnernewSubscriberHoldnewSubscriberFannewSubscriberSwitchnewSubscriberCoincidenceOuternewSubscriberCoincidenceInnerinvalidateSubscriberHeightrecalculateSubscriberHeight propagate propagateFasttoAnyeventSubscribedRooteventSubscribedNevereventSubscribedNoweventSubscribedFaneventSubscribedSwitcheventSubscribedCoincidencegetEventSubscribedHeightsubscribeHoldEvent behaviorHoldbehaviorHoldIdentity behaviorConst behaviorPull behaviorDynreadHoldTrackedreadBehaviorUntracked dynamicHolddynamicHoldIdentity dynamicConst dynamicDyndynamicDynIdentityglobalSpiderTimelineEnv runEventM asksEventEnvdeferputCurrentHeight scheduleClearscheduleIntClearscheduleRootCleargetHoldEventSubscriptionheightBagEmpty heightBagSizeheightBagFromList heightBagAddheightBagRemoveheightBagRemoveMaybe heightBagMaxheightBagVerifynewInvalidatorSwitchnewInvalidatorPull newMapDynrunscheduleMerge' debugFinalizemkWeakPtrWithDebugwithIncreasedDepthtracePropagatetraceInvalidatetraceInvalidateHeightdebugSubscriberdebugSubscriber'tracetraceMwhoCreatedIORef groupByHead listsToForest showStacks filterStackpropagateSubscriberHold runBehaviorMaskInvalidator askParentsRefaskBehaviorHoldInits getDynHoldzeroRefgetRootSubscribedcleanupRootSubscribedsubscribeRootSubscribed newFanIntfanIntSubscribedgetFanSubscribedcleanupFanSubscribedsubscribeFanSubscribedgetSwitchSubscribedcleanupSwitchSubscribedsubscribeSwitchSubscribedgetCoincidenceSubscribedcleanupCoincidenceSubscribedsubscribeCoincidenceSubscribed mergeWithMove mergeCheapmergeCheapWithMoveinvalidateMergeHeightinvalidateMergeHeight'revalidateMergeHeightscheduleMergeSelf checkCyclemergeSubscriber updateMerge mergeGCheap' mergeIntCheap runHoldInitsinitHoldinitDyn newEventEnv clearEventEnvrunFrame zeroHeight invalidHeight succHeightinvalidateCoincidenceHeightupdateSwitchHeightrecalculateCoincidenceHeightcalculateSwitchHeightcalculateCoincidenceHeight invalidate newJoinDynmapDynamicSpiderholdSpiderEventMholdDynSpiderEventMholdIncrementalSpiderEventMbuildDynamicSpiderEventMunsafeNewSpiderTimelineEnvnewSpiderTimelinelocalSpiderTimelinewithSpiderTimeline runSpiderHostrunSpiderHostForTimelinenewEventWithTriggerIOnewFanEventWithTriggerIO$fMonadAtomicRefEventM$fMonadRefEventM$fShowEventLoopException$fExceptionEventLoopException$fMonadBehaviorM$fDeferSomeHoldInitBehaviorM$fGEqTYPESpiderTimelineEnv$fEqSpiderTimelineEnv!$fDeferSomeResetCoincidenceEventM$fDeferSomeEventM$fDeferSomeEventM0$fDeferSomeEventM1$fHasSpiderTimelineGlobal$fDeferSomeMergeInitEventM$fDeferSomeMergeUpdateEventM$fDeferSomeDynInitEventM$fDeferSomeHoldInitEventM$fDeferSomeAssignmentEventM$fHasCurrentHeightxEventM#$fMonadHoldTYPESpiderTimelineEventM%$fMonadSampleTYPESpiderTimelineEventM&$fHasSpiderTimelineLocalSpiderTimeline*$fMonadSampleTYPESpiderTimelineSpiderPullM$fReflexTYPESpiderTimeline($fMonadHoldTYPESpiderTimelineSpiderPushM*$fMonadSampleTYPESpiderTimelineSpiderPushM%$fNotReadySpiderTimelinePerformEventT"$fNotReadySpiderTimelineSpiderHost$fMonadAtomicRefSpiderHost$fMonadRefSpiderHost$fMonadFailSpiderHost$fMonadSpiderHost2$fMonadReflexCreateTriggerSpiderTimelineSpiderHost)$fMonadSampleTYPESpiderTimelineSpiderHost$fPrimMonadSpiderHostFrame$fMonadAtomicRefSpiderHostFrame$fMonadRefSpiderHostFrame'$fNotReadySpiderTimelineSpiderHostFrame$fMonadSpiderHostFrame-$fMonadSubscribeEventSpiderTimelineSpiderHost7$fMonadReflexCreateTriggerSpiderTimelineSpiderHostFrame$fReflexHostSpiderTimeline2$fMonadSubscribeEventSpiderTimelineSpiderHostFrame,$fMonadHoldTYPESpiderTimelineSpiderHostFrame.$fMonadSampleTYPESpiderTimelineSpiderHostFrame'$fMonadHoldTYPESpiderTimelineSpiderHost)$fMonadReflexHostSpiderTimelineSpiderHost'$fMonadReadEventSpiderTimelineReadPhase&$fMonadHoldTYPESpiderTimelineReadPhase($fMonadSampleTYPESpiderTimelineReadPhase$fFunctorReadPhase$fApplicativeReadPhase$fMonadReadPhase$fMonadFixReadPhase$fFunctorSpiderHostFrame$fApplicativeSpiderHostFrame$fMonadFixSpiderHostFrame$fMonadIOSpiderHostFrame$fMonadExceptionSpiderHostFrame$$fMonadAsyncExceptionSpiderHostFrame$fMonadMaskSpiderHostFrame$fMonadThrowSpiderHostFrame$fMonadCatchSpiderHostFrame$fFunctorSpiderHost$fApplicativeSpiderHost$fMonadFixSpiderHost$fMonadIOSpiderHost$fMonadExceptionSpiderHost$fMonadAsyncExceptionSpiderHost$fFunctorSpiderPushM$fApplicativeSpiderPushM$fMonadSpiderPushM$fMonadIOSpiderPushM$fMonadFixSpiderPushM$fFunctorSpiderPullM$fApplicativeSpiderPullM$fMonadSpiderPullM$fMonadIOSpiderPullM$fMonadFixSpiderPullM$fFunctorBehaviorM$fApplicativeBehaviorM$fMonadIOBehaviorM$fMonadFixBehaviorM$fMonadReaderTuple2BehaviorM $fShowHeight $fReadHeight $fEqHeight $fOrdHeight$fBoundedHeight$fShowHeightBag$fReadHeightBag $fEqHeightBag$fOrdHeightBag$fFunctorEventM$fApplicativeEventM $fMonadEventM$fMonadIOEventM$fMonadFixEventM$fMonadExceptionEventM$fMonadAsyncExceptionEventM$fMonadCatchEventM$fMonadThrowEventM$fMonadMaskEventM$fFunctorDynamic0 ProfiledM runProfiledMCostCentreTree_costCentreTree_children!_costCentreTree_cumulativeEntries_costCentreTree_ownEntriesProfiledTimeline profilingDatagetCostCentreStacktoCostCentreTreegetCostCentreTreeformatCostCentreTreeshowProfilingDatawriteProfilingData profileEvent$fMonoidCostCentreTree$fSemigroupCostCentreTree)$fMonadReadEventProfiledTimelineProfiledM*$fMonadReflexHostProfiledTimelineProfiledM$fPrimMonadProfiledM.$fMonadSubscribeEventProfiledTimelineProfiledM$fReflexHostProfiledTimeline$fMonadReaderrProfiledM3$fMonadReflexCreateTriggerProfiledTimelineProfiledM$fMonadRefProfiledM$$fRequesterProfiledTimelineProfiledM&$fMonadQueryProfiledTimelineqProfiledM'$fEventWriterProfiledTimelinewProfiledM)$fDynamicWriterProfiledTimelinewProfiledM*$fBehaviorWriterProfiledTimelinewProfiledM#$fNotReadyProfiledTimelineProfiledM$$fPostBuildProfiledTimelineProfiledM'$fTriggerEventProfiledTimelineProfiledM'$fPerformEventProfiledTimelineProfiledM$fMonadIOProfiledM$fMonadTransProfiledM%$fAdjustableProfiledTimelineProfiledM*$fMonadSampleTYPEProfiledTimelineProfiledM($fMonadHoldTYPEProfiledTimelineProfiledM$fReflexTYPEProfiledTimeline$fFunctorProfiledM$fApplicativeProfiledM$fMonadProfiledM$fMonadFixProfiledM$fMonadExceptionProfiledM$fMonadAsyncExceptionProfiledM$fShowCostCentreTree$fEqCostCentreTree$fOrdCostCentreTree networkView networkHold untilReadyMonadHeadlessApprunHeadlessApp sortableListWorkflow unWorkflowworkflow workflowView mapWorkflowmapWorkflowCheapmonoidal-containers-0.6.5.0-9763b0fb3413fb387d57d7da92923bcffa38d70f01d9df1baa2626aec83ca741getMonoidalMap ghc-internalGHC.Internal.MaybeNothing!!?\\adjust adjustWithKeyalterassocsdeletedeleteAt deleteFindMax deleteFindMin deleteMax deleteMindifferenceWithdifferenceWithKeydropdropWhileAntitoneelemAtelemsfilter filterWithKey findIndexfindMaxfindMinfindWithDefaultfoldMapWithKeyfoldlfoldl' foldlWithKey foldlWithKey'foldrfoldr' foldrWithKey foldrWithKey' fromAscListfromAscListWithfromAscListWithKey fromDescListfromDescListWithfromDescListWithKeyfromDistinctAscListfromDistinctDescListfromDistinctListfromList fromListWithfromListWithKeyfromSetinsertLookupWithKey insertWith insertWithKeyintersectionWithintersectionWithKeyisProperSubmapOfisProperSubmapOfBy isSubmapOf isSubmapOfBykeyslookupGElookupGT lookupIndexlookupLElookupLT lookupMax lookupMinmapmapAccumRWithKeymapAccumWithKeymapEitherWithKeymapKeysmapKeysMonotonic mapKeysWithmapMaybeWithKey mapWithKeymaxViewmaxViewWithKeymember mergeWithKeyminViewminViewWithKey notMembernull partitionpartitionWithKey restrictKeys spanAntitonesplitsplitAt splitLookup splitRoottaketakeWhileAntitone toAscList toDescListtraverseMaybeWithKeytraverseWithKey unionWith unionWithKey unionsWithupdateupdateAtupdateLookupWithKey updateMaxupdateMaxWithKey updateMinupdateMinWithKey updateWithKeyvalid withoutKeyscontainers-0.7-inplaceData.IntMap.InternalData.Map.Internalghc-prim GHC.ClassesEqData.Set.InternalSetGHC.Internal.WeakMaybe Filterable GHC.TypesIntGHC.Internal.Data.Type.CoercionCoercionGHC.Internal.BasefmapliftA2liftA3GHC.Internal.Data.EitherLeftRightJustTrueFalseStringthese-1.2.1-0ca4167b3818481b009ba9ef89863d94bb35d7891cb2f35c8c5da08412d75d3b Data.TheseThisThatTheseData.Patch.Class PatchTargetPatchData.Patch.MapPatchMapdependent-map-0.4.0.0-859255f53588e22516946fb09a49aa7e15b5814d7cbd2fae46bc574329677aa8Data.Dependent.Map.InternalDMap Applicativedependent-sum-0.7.2.0-c21debc69da2457b06bf8f129ea36675e875a228a48b414fa3c7f7455ab1d93aData.Dependent.SumDSummergeWithFoldCheap'semigroupoids-6.0.1-410be30d248b92b6351e6a03557da13dab81019e92af41c38931bc043e4e6a03Data.Functor.Pluszero applyAlwayscomposePatchFunctionsData.Patch.DMapconst2IntPatchDMapWithconst2PatchDMapWith mapPatchDMappatchDMapToPatchMapWithtraversePatchDMaptraversePatchDMapWithKeyweakenPatchDMapWithData.Patch.DMapWithMoveconst2PatchDMapWithMoveWithmapPatchDMapWithMove'patchDMapWithMoveToPatchMapWithMoveWith traversePatchDMapWithMoveWithKeyunPatchDMapWithMoveunsafePatchDMapWithMoveweakenPatchDMapWithMoveWithmapIntMapPatchWithKeypatchMapNewElementspatchMapNewElementsMapData.Patch.MapWithMovepatchMapWithMoveNewElementspatchMapWithMoveNewElementsMapunsafePatchMapWithMove AdditivePatchunAdditivePatchGroupnegateG~~apply PatchDMap unPatchDMapPatchDMapWithMove unPatchMapPatchMapWithMoveunPatchMapWithMoveData.Semigroup.AdditiveAdditive SemigroupDoubleFloatEitherUnqDynMonadGHC.Internal.EnumEnumpredMemoTrie-0.6.9-6d3be7ce9a9c3928e865c2bde571fcb6b8eb4edbd904f4906e6a14713431af3d Data.MemoTrieHasTrieIO"GHC.Internal.Data.Functor.IdentityIdentitybase-4.21.0.0-inplaceControl.Concurrent.ChanChantime-1.14-inplace Data.Time.Clock.Internal.UTCTimeUTCTimeprim-uniq-0.2-4649e157cb676165d5294f0cd75314c003264e780880f9060f48f66f7352955bUnsafe.Unique.TagTagtransformers-0.6.1.2-inplaceControl.Monad.Trans.Class MonadTransTellIdtellId(sequenceIntMapWithAdjustEventWriterTWithBehavior_ProfiledunBehavior_ProfiledDynamic_ProfiledunDynamic_ProfiledEvent_ProfiledunEvent_ProfiledIncremental_ProfiledunIncremental_Profiled