!.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                              !!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''(((((((((((((((((((((((((((()))))))))))********************** * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*|*}*~******************************************************************************************************************************************* * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*|*}*~**************************************************************************************************+++,,,,,,,,,,,,,,,,,,,,,,,,,,,-.......2SafeEX_reflexWhen inserting an item into a , a l 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 .reflexA  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.reflexInsert an item into a .reflexCreate an empty .reflexCheck whether a  is empty.reflexVisit 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.reflexRemove an item from the 6; does nothing if invoked multiple times on the same .reflexThe itemreflexThe  to insert intoreflex Returns a F that ensures the item is retained and allows the item to be removed.None&'-124=>?@AHSX_greflex We can't use  Compose Maybe instead of , because that would make the f` parameter have a nominal type role. We need f to be representational so that we can use safe coerce. reflex Tag type for  to use it as a .reflex can be used to tag a value in one functor with a type representing another functor. This was primarily used with dependent-map < 0.2, in which the value type was not wrapped in a separate functor.reflex stores a value of a given type k% and ensures that a particular type v, is always given for the last type parameterreflexExtract the value from a Const2reflex Convert a  to a regular  reflex Convert a  to an  reflex Convert a  to a regular  6, applying the given function to remove the wrapping  reflexConvert a regular   to a reflexConvert a regular  ;, where the values are already wrapped in a functor, to a reflexConvert a regular  ;, where the values are already wrapped in a functor, to a reflex Convert a  to a regular  \ by forgetting the types associated with the keys, using a function to remove the wrapping  reflex"Map over all key/value pairs in a , potentially altering the key as well as the value. The provided function MUST preserve the ordering of the keys, or the resulting  will be malformed.reflex Union two zs of different types, yielding another type. Each key that is present in either input map will be present in the output.reflexExtract the values of a  of  s.reflexConvert  to a  . Inverse of .reflexConvert  to  . Inverse of .reflex!Run the actions contained in the  reflex Replace the   functor for a DMap'!s values with a different functor!reflexReplace one functor for a DMap'!s values with a different functor"reflexReplace one functor for a DMap's values with the   functor#reflexLike "/, but possibly delete some values from the DMap$reflexEliminate the   functor in a , and replace it with the underlying functor  !"#$  !"#$ None_>reflex Produce a   k (Maybe v) by comparing two   k vs, old and new respectively. Just& represents an association present in new and Nothing, represents an association only present in old but no longer present in new. Similar to ? but doesn't require  > on the values, thus can't tell if a value has changed or not.?reflex 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 >9 for a similar but weaker version which does not require  F on the values but thus can't indicated a value not changing between old and new with Nothing.@reflexGiven 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 / and 0.AreflexSplit a   k (Either a b) into Map k a and Map k b, equivalent to  idBreflexGiven 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 ( m) ==  (@ patch m) but avoids the intervening Map and needs no values.>?@AB>?@ABSafeEXCreflexWhen inserting an item into a D, a Cl is returned. If the caller retains the ticket, the item is guranteed to stay in memory (and thus in the D=). The ticket can also be used to remove the item from the D3 prematurely (i.e. while it is still alive), using J.DreflexA D 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 D will continue to refer to them.Ereflex#The items referenced by the WeakBagFreflexInsert an item into a D.GreflexCreate an empty D.Hreflex Create a D+ with one item; equivalent to creating the D with G , then using F.IreflexVisit 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.JreflexRemove an item from the D6; does nothing if invoked multiple times on the same C.FreflexThe itemreflexThe D to insert intoreflex8An arbitrary value to be used in the following callbackreflexA callback to be invoked when the item is removed (whether automatically by the item being garbage collected or manually via J)reflex Returns a CF that ensures the item is retained and allows the item to be removed.CDEFGHIJDCGHFIJENoneX_KreflexmA reference to some value which can be garbage collected if there are only weak references to the value left.N? 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 L using O) if the value hasn't been collected yet.Synonymous with .LreflexA K0 which has been promoted to a strong reference. M; can be used to get the referred to value without fear of Nothing, and Q% can be used to get the weak version.Mreflex Return the a kept alive by the given L.EThis needs to be in IO so we know that we've relinquished the ticket.NreflexGet the value referred to by a K& if it hasn't yet been collected, or Nothing if it has been collected.OreflexTry to create a L for the given K> which will ensure the value referred remains alive. Returns JustM if the value hasn't been collected and a ticket can therefore be obtained, Nothing if it's been collected.Preflex Create a L# directly from a value, creating a K, in the process which can be obtained with M.Qreflex Demote a L); which ensures the value is alive, to a K: which doesn't. Note that unless the ticket for the same KE is held in some other way the value might be collected immediately.Rreflex%A weak reference that is always emptyKLMNOPQRLKPMQNORSafe]Sreflex=A class for values that combines filtering and mapping using  . Morally, S ~ KleisliFunctor . Also similar is the  Witherable typeclass, but it requires  Foldable f and  Traverable f , and e.g. Event is instance of neither.A definition of T! must satisfy the following laws: identityT  "a  compositionT (f <=< g) "a T f . T gTreflex(Combined mapping and filtering function.Wreflex fmapMaybe = mapMaybeXreflex@fmapMaybe = (=<<)STSTSafeHV^YreflexA Y: type represents a kind of change made to a datastructure.If an instance of Y is also an instance of , it should obey the law that 5applyAlways (f <> g) == applyAlways f . applyAlways g.[reflexApply the patch p a to the value a#. If no change is needed, return .\reflexApply a Y/; if it does nothing, return the original value]reflexLike '(.)', but composes functions that return patches rather than functions that return new values. The Semigroup instance for patches must apply patches right-to-left, like '(.)'.^reflex  can be used as a Y% that always fully replaces the valueY[Z\]Y[Z\]None 456HMV_reflexY for  u which represents insertion or deletion of keys in the mapping. Internally represented by 'IntMap (Maybe a)', where Just means insert/update and Nothing means delete.areflexMap a function  Int -> a -> b over all as in the given _ a. (that is, all inserts/updates), producing a  PatchIntMap b.breflexMap an effectful function Int -> a -> f b over all as in the given _ a. (that is, all inserts/updates), producing a f (PatchIntMap b).creflex Extract all a s inserted/updated by the given _ a.dreflexConvert the given _ a into an   a2 with all the inserts/updates in the given patch.ereflexSubset the given   a> to contain only the keys that would be deleted by the given _ a.freflexa <> b will apply the changes of b and then apply the changes of aZ. If the same key is modified by both patches, the one on the left will take precedence.greflex-Apply the insertions or deletions to a given  ._`abcde_`abcde NoneHVureflex<Make an immutable snapshot of the datastructure and clear it_`bcdelmnopqrstuvlmnosutv_`bpqrcde SafeHV_wreflexA set of changes to a  e. Any element may be inserted/updated or deleted. Insertions are represented as values wrapped in &, while deletions are represented as szreflex7Returns all the new elements that will be added to the  {reflex7Returns all the new elements that will be added to the  |reflexping a wH will alter all of the values it will insert. Deletions are unaffected.}reflex The empty w$ contains no insertions or deletions~reflexa <> b will apply the changes of b and then apply the changes of aZ. If the same key is modified by both patches, the one on the left will take precedence.reflex-Apply the insertions or deletions to a given  .wxyz{wxyz{ None -1HMSVX_= reflexA set of changes to a R. Any element may be inserted/updated or deleted. Insertions are represented as  (Just value)&, while deletions are represented as  Nothing.reflexMap a function  v a -> v' a( over any inserts/updates in the given  k v to produce a  k v'.reflexMap an effectful function v a -> f (v' a)( over any inserts/updates in the given  k v to produce a  k v'.reflexMap an effectful function k a -> v a -> f (v' a)( over any inserts/updates in the given  k v to produce a  k v'.reflex Weaken a  k v to a w (Some k) v' using a function  v a -> v'- to weaken each value contained in the patch.reflexConvert a weak  ( k a) v where the a is known by way of the Const2 into a w k v' using a rank 1 function  v a -> v'.reflex Convert a w k v into a  ( k a) v' using a function  v -> v' a.reflex Convert a _ v into a  ( Int a) v' using a function  v -> v' a.reflex[Get the values that will be replaced or deleted if the given patch is applied to the given .reflex-Apply the insertions or deletions to a given . None 456>HQVX_1reflexKHelper data structure used for composing patches using the monoid instance.reflex6Describe where a key's old value will go. If this is Q, that means the key's old value will be moved to the given other key; if it is !, that means it will be deleted.reflex1Describe how a key's new value should be producedreflexInsert the given value herereflex,Delete the existing value, if any, from herereflex&Move the value here from the given keyreflexqHolds the information about each key: where its new value should come from, and where its old value should go toreflex+Where do we get the new value for this key?reflex`If the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?reflexFPatch a DMap with additions, deletions, and moves. Invariant: If key k1 is coming from  From_Move k2 , then key k2 should be going to Just k1D, and vice versa. There should never be any unpaired From/To keys.reflex Create a , validating itreflex Create a & that inserts everything in the given  reflex+Extract the internal representation of the reflexMake a  k v7 which has the effect of inserting or updating a value v to the given key k, like .reflexMake a  k v= which has the effect of moving the value from the first key k to the second key k, equivalent to:   src (maybe map ( dst) (Map.lookup src map)) reflexMake a  k vI which has the effect of swapping two keys in the mapping, equivalent to: e let aMay = Map.lookup a map bMay = Map.lookup b map in maybe id (Map.insert a) (bMay , aMay) . maybe id (Map.insert b) (aMay 0 bMay) . Map.delete a . Map.delete b $ map reflexMake a  k vF which has the effect of deleting a key in the mapping, equivalent to .reflexWrap a   k (NodeInfo k v)# representing patch changes into a  k v", without checking any invariants.Warning:B when using this function, you must ensure that the invariants of ) are preserved; they will not be checked.reflex7Returns all the new elements that will be added to the  .reflex Return a   k v- with all the inserts/updates from the given  k v.reflex Create a  that, if applied to the given  P, will sort its values using the given ordering function. The set keys of the   is not changed.reflex Create a  that, if applied to the first   provided, will produce a  $ with the same values as the second  > but with the values sorted with the given ordering function.reflex Create a  that, if applied to the first  $ provided, will produce the second  .reflex Change the  value of a reflex Change the  value of a  , using a   (or , #, etc.) action to get the new valuereflexSet the  field of a reflexHCompose patches having the same effect as applying the patches in turn: \ (p <> q) == \ p . \ qreflex6Apply the insertions, deletions, and moves to a given  reflexHCompose patches having the same effect as applying the patches in turn: \ (p <> q) == \ p . \ q None&'-=>?@AHQSVX_{B!reflexKHelper data structure used for composing patches using the monoid instance.reflex$Higher kinded 2-tuple, identical to Data.Functor.Product from base "e 4.9reflex"Type alias for the "to" part of a .  ( k)) means the key is moving to another key, ComposeMaybe Nothing for any other operation.reflexNStructure describing a particular change to a key, be it inserting a new key ( From_Insert), updating an existing key ( From_Insert again), deleting a key ( From_Delete), or moving a key ( From_Move).reflex<Insert a new or update an existing key with the given value v areflexDelete the existing keyreflex"Move the value from the given key k a^ to this key. The source key should also have an entry in the patch giving the current key as  _nodeInfo_to$, usually but not necessarily with  From_Delete.reflexCStructure which represents what changes apply to a particular key. _nodeInfo_fromm specifies what happens to this key, and in particular what other key the current key is moving from, while  _nodeInfo_toG specifies what key the current key is moving to if involved in a move.reflexEChange applying to the current key, be it an insert, move, or delete.reflexCWhere this key is moving to, if involved in a move. Should only be ComposeMaybe (Just k) when there is a corresponding .reflexLike  , but for . Each key carries a a which describes how it will be changed by the patch and connects move sources and destinations. Invariants: A key should not move to itself.HA move should always be represented with both the destination key (as a ) and the source key (as a  ( destination))reflexTest whether a  satisfies its invariants.reflexEnumerate what reasons a + doesn't satisfy its invariants, returning [] if it's valid.reflexMake a  k v7 which has the effect of inserting or updating a value v a to the given key k a, like .reflexMake a  k v= which has the effect of moving the value from the first key k a to the second key k a, equivalent to:   src (maybe dmap ( dst) (DMap.lookup src dmap)) reflexMake a  k vI which has the effect of swapping two keys in the mapping, equivalent to: j let aMay = DMap.lookup a dmap bMay = DMap.lookup b dmap in maybe id (DMap.insert a) (bMay mplus- aMay) . maybe id (DMap.insert b) (aMay mplus3 bMay) . DMap.delete a . DMap.delete b $ dmap reflexMake a  k vF which has the effect of deleting a key in the mapping, equivalent to .reflex Extract the ) representing the patch changes from the .reflexWrap a # representing patch changes into a ", without checking any invariants.Warning:B when using this function, you must ensure that the invariants of ) are preserved; they will not be checked.reflexWrap a # representing patch changes into a = while checking invariants. If the invariants are satisfied, Right p is returned otherwise  Left errors.reflexMap a natural transform v -> v'$ over the given patch, transforming  k v into  k v'.reflexTraverse an effectful function forall a. v a -> m (v ' a)$ over the given patch, transforming  k v into m ( k v').reflexMap an effectful function !forall a. k a -> v a -> m (v ' a)$ over the given patch, transforming  k v into m ( k v').reflex Map a function which transforms  k v a into a  k v' a over a  k v a.reflex+Map an effectful function which transforms  k v a into a f ( k v' a) over a  k v a.reflex Weaken a  to a  by weakening the keys from k a to  k) and applying a given weakening function  v a -> v' to values.reflexWeaken a  (Const2 k a) v to a  k v'(. Weaken is in scare quotes because the O has already disabled any dependency in the typing and all points are already a*, hence the function to map each value to v' is not higher rank.reflex Strengthen a  k v into a 'PatchDMapWithMove ( k a); that is, turn a non-dependently-typed patch into a dependently typed one but which always has a constant key type represented by #. Apply the given function to each v to produce a v' a. Completemented by reflexcGet the values that will be replaced, deleted, or moved if the given patch is applied to the given .reflex6Apply the insertions, deletions, and moves to a given .reflexHCompose patches having the same effect as applying the patches in turn: \ (p <> q) == \ p . \ qreflexTest whether two  k v# contain the same patch operations.reflexHCompose patches having the same effect as applying the patches in turn: \ (p <> q) == \ p . \ q""NoneHVreflexThe elements of an  0 can be considered as patches of their own type.reflexAn  ! is one where (<>) is commutativereflexA  is a  $ where every element has an inverse..YZ[\]_`abcdwxyz{.YZ[\]_`abcdwxyz{None&',-8=>?@ACHINSUVX_rkreflexAn 6 type can be built by accumulating occurrences of an .reflexAn  allows you to efficiently  an Q based on a key. This is much more efficient than filtering for each key with T.reflex Retrieve the % for the given key. The type of the H is determined by the type of the key, so this can be used to fan-out  s whose sub-s have different types.Using  s and the A primitive is far more efficient than (but equivalent to) using T0 to select only the relevant occurrences of an . reflex ' designates monads that can create new  s based on s; usually this will be  or a monad based on it.  > is required to create any stateful computations with Reflex. reflex Create a new ` whose value will initially be equal to the given value and will be updated whenever the given 9 occurs. The update takes effect immediately after the * occurs; if the occurrence that sets the > (or one that is simultaneous with it) is used to sample the , it will see the old value of the , not the new one. reflex Create a B value using the given initial value that changes every time the  occurs. reflex Create an B value using the given initial value that changes every time the  occurs.reflex Create a new F that only occurs only once, on the first occurrence of the supplied .reflex9 designates monads that can read the current value of a . This includes both  and .reflexGet the current value in the reflexThe h 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 12 implementation is recommended.reflex4A container for a value that can change over time. Qs can be sampled at will, but it is not possible to be notified when they changereflex5A stream of occurrences. During any given frame, an ~ is either occurring or not occurring; if it is occurring, it will contain a value of the given type (its "occurrence type")reflexvA container for a value that can change over time and allows notifications on changes. Basically a combination of a  and an , with a rule that the ! will change if and only if the  fires.reflexAn  is a more general form of a . 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.reflex=A monad for doing complex push-based calculations efficientlyreflex=A monad for doing complex pull-based calculations efficientlyreflexAn  with no occurrencesreflex Create a  that always has the given valuereflex Create an  from another $; the provided function can sample  s and hold Ws, and use the results to produce a occurring (Just) or non-occurring (Nothing) resultreflexLike  but intended for functions that the implementation can consider cheap to compute for performance considerations. WARNING: The function passed to / may be run multiple times without any caching.reflex Create a  by reading from other ;s; the result will be recomputed whenever any of the read  s changesreflex,Merge a collection of events; the resulting  will only occur if at least one input event is occurring, and will contain all of the input keys that are occurring simultaneouslyreflexEfficiently fan-out an event to many destinations. This function should be partially applied, and then the result applied repeatedly to create child eventsreflex Create an 8 that will occur whenever the currently-selected input  occurs reflex Create an Z that will occur whenever the input event is occurring and its occurrence value, another , is also occurring!reflex Extract the  of a ."reflex Extract the  of the .#reflex Create a new  . The given 9 must always return the most recent firing of the given  , if any.$reflex Create a new  . The given PullMr's value must always change in the same way that the accumulated application of patches would change that value.%reflex1Create a merge whose parents can change over time&reflexExperimental: Create a merge whose parents can change over time; changing the key of an Event is more efficient than with mergeIncremental'reflex Extract the  component of an (reflex Extract the  component of an )reflex Convert an  to a *reflex Construct a ! for a  given an ! for its occurrence type+reflex Construct a ! for an  given an ! for its occurrence type,reflex Construct a ! for a  given an ! for its occurrence type0reflex Coerce a 2 between representationally-equivalent value types1reflex Coerce an 7 between representationally-equivalent occurrence types2reflex Coerce a 2 between representationally-equivalent value types3reflex Construct a  from a  and an . The  must change when and only when the  fires, such that the  Behavior'9s value is always equal to the most recent firing of the *; if this is not the case, the resulting # will behave nondeterministically.4reflex Construct a  value that never changes>reflex Create an  from another %. The provided function can sample  s and hold s.?reflexFlipped version of .@reflexRotated version of ".AreflexRotated version of #.BreflexFlipped version of T.Creflex6Filter 'f a' using the provided predicate. Relies on B.DreflexFilter $s from 'f (Either a b)' into a.EreflexFilter %s from 'f (Either a b)' into b.Freflex%Replace each occurrence value of the  with the value of the  at the time of that occurrence.Greflex%Replace each occurrence value of the  with the value of the  at that time; if it is +, fire with the contained value; if it is , drop the occurrence.Hreflex Create a new ' that combines occurrences of supplied  with the current value of the .Ireflex Create a new  that occurs when the supplied 7 occurs by combining it with the current value of the .Jreflex Create a new = by combining each occurrence with the current value of the H. The occurrence is discarded if the combining function returns NothingKreflex Create a new > that occurs on all but the first occurrence of the supplied .LreflexCreate a tuple of two As with the first one occurring only the first time the supplied B occurs and the second occurring on all but the first occurrence.MreflexYTake 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 ( for which the given predicate returns &. When first 'A is returned, do not fire, and permanently stop firing, even if &+ values would have been encountered later.NreflexbTake 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 > for which the given predicate returns 'Just b'. When first t is returned, do not fire, and permanently stop firing, even if 'Just b' values would have been encountered later.OreflexYDrop the streak of occurrences starting at the current time for which the event returns &.EStarting at the current time, do not fire all the occurrences of the ( for which the given predicate returns &. When 'G is first returned, do fire, and permanently continue firing, even if &+ values would have been encountered later.PreflexpBoth take and drop the streak of occurrences starting at the current time for which the event returns 'Just b'.SFor the left event, starting at the current time, fire all the occurrences of the 7 for which the given function returns 'Just b'. When s 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.QreflexSplit the supplied  into two individual Hs occurring at the same time with the respective values from the tuple.RreflexPrint the supplied ( and the value of the " on each occurrence. This should only be used for debugging.JNote: As with Debug.Trace.trace, the message will only be printed if the  is actually used.SreflexEPrint the output of the supplied function on each occurrence of the . This should only be used for debugging.JNote: As with Debug.Trace.trace, the message will only be printed if the  is actually used.Treflex Create a new $ that occurs if at least one of the qs in the list occurs. If multiple occur at the same time they are folded from the left with the given function.Ureflex Create a new $ that occurs if at least one of the hs in the list occurs. If multiple occur at the same time the value is the value of the leftmost event.Vreflex Create a new $ that occurs if at least one of the :s in the list occurs and has a list of the values of all s occurring at that time.Xreflex Create a new  combining the map of  s into an L that occurs if at least one of them occurs and has a map of values of all s occurring at that time.YreflexLike X but for  .Zreflex1Create a merge whose parents can change over time[reflex1Create a merge whose parents can change over time\reflexExperimental: Create a merge whose parents can change over time; changing the key of an Event is more efficient than with mergeIncremental]reflex)Split the event into separate events for $ and % values.^reflex)Split the event into separate events for ) and *G values, allowing them to fire simultaneously when the input value is +._reflexSplit the event into an 4 that allows efficient selection of the individual s.`reflexSwitches 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 a and b\ unless you are absolutely sure you need to act on the new event in the coincidental case.areflexSwitches 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.breflexswitches 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 %, 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.creflexWhen the given outer event fires, condense the inner events into the contained patch. Non-firing inner events will be replaced with deletions.dreflexSee cereflexSee cgreflex Create a new " that only occurs if the supplied  occurs and the # is true at the time of occurrence.hreflexoCreate a new behavior given a starting behavior and switch to the behavior carried by the event when it fires.ireflex Combine two <s. The result will change whenever either (or both) input  changes. Equivalent to zipDynWith (,).jreflex Combine two Vs with a combining function. The result will change whenever either (or both) input  changes. More efficient than ".kreflexThis function converts a  whose elements are  s into a  a. Its implementation is more efficient than doing the same through the use of multiple uses of j or  operators.lreflexConvert a list of  s into a  list.mreflex Create a new / by applying a combining function to a list of snreflex Create a new % that occurs when the first supplied $ occurs unless the second supplied  occurs simultaneously.reflexAccumulate occurrences of an E, producing an output occurrence each time. Discard the underlying .reflexAccumulate occurrences of an N, possibly producing an output occurrence each time. Discard the underlying .reflexAccumulate occurrences of an  , using a O action and producing an output occurrence each time. Discard the underlying .reflexAccumulate occurrences of an  , using a Y action and possibly producing an output occurrence each time. Discard the underlying .reflex Create a new  by combining each occurrence with the next value of the list using the supplied function. If the list runs out of items, all subsequent  occurrences will be ignored.reflex0Assign a number to each occurrence of the given , starting from 0reflex0Assign a number to each occurrence of the given reflex0Assign a number to each occurrence of the given !; discard the occurrences' valuesreflex&This is used to sample the value of a  using an .The : operator is intended to be used in conjunction with the  instance for .9This is useful when we want to combine the values of one  and the value of several s at the time the  is firing. If we have: Lf :: a -> 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: HattachWith (\(x1, x2) y -> f x1 x2 y) ((,) <$> b1 <*> b2) e :: Event t dGor a variation involing a custom data type to hold the combination of 8s even when that combination might only ever be used by f.#A more suggestive example might be: chandleMouse <$> bPlayerState <*> bMousePosition <@> eMouseClick :: Event t (GameState -> GameState)reflexAn version of $ that does not use the value of the .Alternatively, it is F in operator form.>This is useful when we want to combine the values of several (s at particular points in time using an  style syntax. If we have: Gg :: 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 ) is being used only to act as a trigger.reflex Create a new - that occurs if at least one of the supplied Bs occurs. If both occur at the same time they are combined using ,.reflex Alias for reflexRun both sides of a +$ monadically, combining the results.reflexNever: - = .reflex' intersection (convenient interface to  ).reflex' intersection (convenient interface to  ).reflexILeft-biased event union (prefers left event on simultaneous occurrence). STYZ[\]_`abcdwxyz{     !" #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!" #$%&'()*+,-./012     4>UXYZ\[cedVTnoQ]^_ qp`abfFGHIJgklmijrstuvwxyz{|}~56789:;<KLMNOPhRS3WSTBCDE?@A=44None&'=>?@ACEHISVXreflex. designates monads that can run reflex frames.reflexGPropagate 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.kThis 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.reflex&Run a frame without any events firing.2This function should be used when you want to use  and   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  or   are called.aThis function is commonly used to set up the basic event network when the application starts up.reflexCA monad where new events feed from external sources can be created.reflexCreates a root , (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.aAny 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.reflex)Monad that allows to read events' values.reflexRead the value of an  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 acta 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 .reflexMonad 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 readEventreflex.Subscribe to an event and set it up if needed. This function will create a new  from an $. 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.reflexUFramework implementation support class for the reflex implementation represented by t.reflexLike !, but without reading any events.reflex/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 M the event trigger to trigger this event. When the event is not active, the IORef will contain u. This allows event sources to be more efficient, since they don't need to produce events when nobody is listening.reflex$Fire the given trigger if it is not .reflex$Fire the given trigger if it is not , and read from the given .None=?@AC?reflex efficiently collects  values using  and combines them via  to provide an  result.None=?@AC`reflex efficiently collects  values using , and combines them monoidally to provide a  result.None=?@AFҘreflexA  whose " - will never fire with the same value as the !  Behavior'Gs 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 !, a full comparison is performed.reflex Construct a ) by eliminating redundant updates from a .reflexRetrieve a normal  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  G 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  B instance, but can be equal by pointer equality. This may cause " to lose changes from NaN to NaN.reflex3Create 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 uniqDynamicNone&'-.1=>?@AHNSUVX_\"7reflex Poor man's Generics for product types only.reflexWIndicates that all elements in a type-level list are applications of the same functor.reflexThis class allows s and FHlistFs to be built from regular lists; they must be contiguous and sorted.reflex.A typed index into a typed heterogeneous list.reflexLike +, but with a functor wrapping each element.reflex_A heterogeneous list whose type and length are fixed statically. This is reproduced from the m package due to integration issues, and because very little other functionality from that library is needed. reflex2Represents a time changing value together with an 2 that can efficiently detect when the underlying j 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) dMHowever, the when getDemuxed is used multiple times, the complexity is only  O(log(n)), rather than O(n) for fmap. reflexMap a sampling function over a . reflexFlipped version of   reflex Create a new ; that only signals changes if the values actually changed. reflex Create a new ' that changes only when the underlying ) changes and the given function returns '- when given both the old and the new values.reflex Dynamic Maybe that can only update from Nothing to Just or Just to Just (i.e., cannot revert to Nothing)reflex Create a & that accumulates values from another +. This function does not force its input  until the output  is forced.reflexLike E, but the the accumulator function may decline to update the result Dynamic's value.reflex Create a 6 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 .reflexLike ", but the combining function is a  action, so it can  existing  Behaviors and   new ones.reflex Create a H using the provided initial value and change it each time the provided = 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 "  will fire in the ! case, and will not fire in the  case.reflexLike ", but the combining function is a  action, so it can  existing  Behaviors and   new ones.reflex Create a new $ that counts the occurrences of the .reflex Create a new > using the initial value that flips its value every time the  occurs.reflexSwitches to the new  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.reflexSwitches to the new . whenever it receives one. Switching occurs before the inner  fires - so if the q changes and both the old and new inner Events fire simultaneously, the output will fire with the value of the new .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.reflexSplit a  pair into a pair of sreflex Convert a   with  elements into a  of a   with non- elements.reflexConvert a list with  elements into a  of a list with non-0 elements, preserving the order of the elements.reflex Combine a  of a   of  s into a ! with the current values of the  s in a map.reflexPrint the value of the K when it is first read and on each subsequent change that is observed (as R3), prefixed with the provided string. This should only be used for debugging.tNote: Just like Debug.Trace.trace, the value will only be shown if something else in the system is depending on it.reflexHPrint the result of applying the provided function to the value of the K when it is first read and on each subsequent change that is observed (as R). This should only be used for debugging.tNote: Just like Debug.Trace.trace, the value will only be shown if something else in the system is depending on it.reflexReplace the value of the  with the current value of the  each time the  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 X won't be updated until the end of the frame. Additionally, this means that the output / may not be used to directly change the input 8, because that would mean its value depends on itself.  When creating cyclic data flows, generally tag (current d) e is preferred. reflex Attach the current value of the  to the value of the  each time it occurs.Note: attachPromptlyDyn d is not the same as attach (current d). See  for details.!reflex!Combine the current value of the  with the value of the  each time it occurs.Note: attachPromptlyDynWith f d is not the same as attachWith f (current d). See  for details."reflex Create a new J by combining the value at each occurrence with the current value of the A 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.#reflex Factor a Dynamic t (Maybe a) into a Dynamic t (Maybe (Dynamic t a)), such that the outer  is updated only when the Maybe's constructor chages from  to 3 or vice-versa. Whenever the constructor becomes  , an inner / will be provided, whose value will track the a inside the ; when the constructor becomes , the existing inner W will become constant, and will not change when the outer constructor changes back to .&reflex Demultiplex an input value to a  T with many outputs. At any given time, whichever output is indicated by the given  will be &.'reflex"Select a particular output of the  J; this is equivalent to (but much faster than) mapping over the original 4 and checking whether it is equal to the given key.(reflex5Collect a hetereogeneous list whose elements are all s into a single @ whose value represents the current values of all of the input s.)reflex8Convert a datastructure whose constituent parts are all s into a single K whose value represents all the current values of the input's consitutent s.*reflexMap a function over a .+reflexFlipped version of *.,reflex Split the  into two 2s, each taking the respective value of the tuple.-reflex Merge the  values using their   instance..reflex1This function no longer needs to be monadic; see ./reflex Merge two 7s into a new one using the provided function. The new 1 changes its value each time one of the original s changes its value.0reflex'A psuedo applicative version of ap for . Example useage: do person <- Person `mapDyn` dynFirstName `apDyn` dynListName `apDyn` dynAge `apDyn` dynAddress1reflexIThis function no longer needs to be monadic, so it has been replaced by ', which is pure.2reflexIThis function no longer needs to be monadic, so it has been replaced by (, which is pure.3reflexIThis function no longer needs to be monadic, so it has been replaced by ), which is pure.4reflex"This function has been renamed to  to clarify its semantics.5reflex"This function has been renamed to   to clarify its semantics.6reflex"This function has been renamed to ! to clarify its semantics.7reflex"This function has been renamed to " to clarify its semantics.8reflexCombine an inner and outer  such that the resulting Dynamic's current value will always be equal to the current value's current value, and will change whenever either the inner or the outer (or both) values change.9reflex'WARNING: This function is only pure if a's  1 instance tests representational equality. Use  H instead, which is pure in all circumstances. Also, note that, unlike nub[, this function does not prevent all recurrences of a value, only consecutive recurrences.:reflex'WARNING: This function is only pure if a's  1 instance tests representational equality. Use  . instead, which is pure in all circumstances.;reflex'WARNING: This function is impure. Use   instead.N "!34k      !"#$%&'()*+,-./0123456789:;N!"   4 !"#$%  k &')(305673/.2+18*-9,4:;2None &'GQUVXnf0reflexThis 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.IreflexQuote a 9 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 aJreflex Antiquote a  expression. This can only be used inside of a L quotation.Kreflex Create a  value using other Us 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.LreflexLike I), but wraps its result monadically using 1(. This is no longer necessary, due to  being an instance of  .MreflexLike K), but wraps its result monadically using 1(. This is no longer necessary, due to  being an instance of  .IJKLMIJKLMThis module defines the N classNone=?@ACq"NreflexN efficiently collects  values using O, and combines them monoidally to provide a  result.NONONone,=?@ACHSVX_xRreflexA  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. QRSTUVWXY RSTUVWXYQNone14567=>?@AHIMVXg{^reflexDeletes a key, returning  if the result is empty.p23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~[\]^_`a[\]^_`aNone.=?@ACHUVX?freflexf. represents an action that is notified via an u when it has finished executing. Note that the specific definition of "finished" is determined by the instance of f, but the intent is to allow s and Ts to be safely sampled, regardless of where they were created, when the post-build  fires. The post-build - will fire exactly once for an given action.greflexRetrieve the post-build  for this action.fgfgNone=?@AHNSVX_nreflexyDisplay 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.oreflexLCreate a dynamically-changing set of Event-valued widgets. This is like l$, specialized for widgets returning  Event t a. l would return Dynamic t (Map k (Event t a)) in this scenario, but o flattens this to Event t (Map k a) via .preflexTCreate a dynamically-changing set of widgets, one of which is selected at any time.rreflexZCreate a dynamically-changing set of widgets from a Dynamic key/value map. Unlike the withKeyU variants, the child widgets are insensitive to which key they're associated with.sreflexACreate a dynamically-changing set of widgets from a Dynamic list.preflexCurrent selection keyreflexDynamic key/value mapreflexFunction to create a widget for a given key from Dynamic value and Dynamic Bool indicating if this widget is currently selectedreflexcEvent that fires when any child's return Event fires. Contains key of an arbitrary firing widget.qreflexCurrent selection keyreflexDynamic key/value mapreflexFunction to create a widget for a given key from Dynamic value and Dynamic Bool indicating if this widget is currently selectedreflexcEvent that fires when any child's return Event fires. Contains key of an arbitrary firing widget. klmnopqrs klmnopqrsNone /=?@AGHVXtreflexA completely pure-functional 6 timeline, identifying moments in time with the type t.reflexThe  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. uvwxyz{|t tuvwxyz{|None 2=>?@ACHMV4reflexiThis type keeps track of the multiplicity of elements of the view selector that are being used by the appreflexNB: QueryMorphism's must be group homomorphisms when acting on the query type and compatible with the query relationship when acting on the query resultreflex The SemigroupMonoidGroup instances for a ViewSelector should use this function which returns Nothing if the result is 0. This allows the pruning of leaves that are no longer wanted.None =?@ACHNVreflexA % action can trigger requests of type  Request m a based on !s, and receive responses of type  Response m a in return. Note that the a type can vary within the C 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 3.reflexThe type of requests that this  can emitreflex The type of responses that this  can receivereflex"Emit a request whenever the given / fires, and return responses in the resulting .reflex"Emit a request whenever the given ! fires, and ignore all responses.reflex"Emit a request whenever the given : fires, and unwrap the responses before returning them.  Response m must be  .None=?@ACkreflex$ represents actions that can create s that can be triggered by  actions.reflexCreate a triggerable =. Whenever the resulting function is called, the resulting P will fire at some point in the future. Note that this may not be synchronous.reflexLike T, but the callback itself takes another callback, to be invoked once the requested D occurrence has finished firing. This allows synchronous operation.reflexLike , but with setup and teardown. This relatively complex type signature allows any external listeners to be subscribed lazily and then removed whenever the returned  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.None=>?@ACHSUVX8reflex= represents actions that can trigger other actions based on s.reflex^The type of action to be triggered; this is often not the same type as the triggering action.reflex*Perform the action contained in the given  whenever the ' fires. Return the result in another . Note that the output , will generally occur later than the input  , since most % actions cannot be performed during  propagation.reflexLike G, but do not return the result. May have slightly better performance.reflexLike , but the resulting ! 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). None 4=?@AHMVݮreflexA basic implementation of .reflexA reference to an  suitable for firing with .reflexA value with which to fire an G, as well as a callback to invoke after its propagation has completed.reflexRun a # action. The argument should be a  into which js can be passed; it is expected that some other thread will be responsible for popping values out of the  and firing their s.reflexRetrieve the current :; event trigger invocations pushed into it will be fired.  !None2>@AHNPVX reflex)UTC time immediately after the last tick.reflexNumber of time periods since t0reflex:Amount of time already elapsed in the current tick period.reflexSpecial case of < that uses the post-build event to start the tick thread.reflexSpecial case of r that uses the post-build event to start the tick thread and the time of the post-build as the tick basis time.reflexSend events over time with the given basis time and interval If the system starts running behind, occurrences will be dropped rather than buffered Each occurrence of the resulting event will contain the index of the current interval, with 0 representing the basis timereflexBGeneralization of tickLossyFrom that takes dt and t0 in the event.reflex:Delay an Event's occurrences by a given amount in seconds.reflexSend events with Poisson timing with the given basis and rate Each occurrence of the resulting event will contain the index of the current interval, with 0 representing the basis timereflexSend events with Poisson timing with the given basis and rate Each occurrence of the resulting event will contain the index of the current interval, with 0 representing the basis time. Automatically begin sending events when the DOM is builtreflexSend events with inhomogeneous Poisson timing with the given basis and variable rate. Provide a maxRate that you expect to support.reflexSend events with inhomogeneous Poisson timing with the given basis and variable rate. Provide a maxRate that you expect to supportreflexBlock occurrences of an Event until the given number of seconds elapses without the Event firing, at which point the last occurrence of the Event will fire.reflexWhen the given m occurs, wait the given amount of time and collect all occurrences during that time. Then, fire the output  with the collected output.reflexThrottle an input event, ensuring that at least a given amount of time passes between occurrences of the output event. If the input event occurs too frequently, the output event occurs with the most recently seen input value after the given delay passes since the last occurrence of the output. If the output event has not occurred recently, occurrences of the input event will cause the output event to fire immediately.reflexThe length of a tick intervalreflex)The basis time from which intervals countreflexEvent 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.reflexEvent 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.reflexPoisson event rate (Hz)reflexBaseline time for eventsreflexEvent 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.reflexPoisson event rate (Hz)reflexBaseline time for events"None&'1=?@AEGHMNSUVXreflexA basic implementation of .reflexJWe 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 anotherreflexLRuns in reverse to accommodate for the fact that we accumulate it in reversereflex with its arguments flippedreflexRun a  action. The resulting V will fire whenever requests are made, and responses should be provided in the input . The W keys will be used to return the responses to the same place the requests were issued.  #None/1=>?@AGHMVX*+,-.10/23456789:23-.10/456789*+,:$None.=?@AHMNSUVX#Wreflex#Provides a basic implementation of f.ZreflexRun a W action. An [ should be provided that fires immediately after the action is finished running; no other s should fire first.]reflex DeprecatedWXYZ[\WXYZ[\%None&'-1=>?@AEHMSUVXh,Grreflex#Provides a basic implementation of !. Note that, despite the name, r is not an instance of .ureflex+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.xreflexRun a r action, returning a u$ that allows the caller to trigger s while ensuring that * actions are run at the appropriate time.rstuvwxrstuvwx&None=?@AEHMSUVX5reflexA basic implementation of .reflex-WARNING: Do not construct this directly; use  insteadreflexRun a  action.reflexGiven a function like S& for the underlying monad, implement S for ?. This is necessary when the underlying monad doesn't have a R& instance or to override the default R behavior.reflexLike  , but for sequenceIntMapWithAdjust.reflexLike  , but for W.reflex$Map a function over the output of a .reflex+Change the monad underlying an EventWriterT'None/1=?@AHMSVX_9reflexawithQueryT's QueryMorphism argument needs to be a group homomorphism in order to behave correctlyreflex}dynWithQueryT's (Dynamic t QueryMorphism) argument needs to be a group homomorphism at all times in order to behave correctly4None:8 (None&'1=?@AHMPSVX_@(reflexA basic implementation of .reflexRun a Z action. The dynamic writer output will be provided along with the result of the action.reflex$Map a function over the output of a .reflexWhen the execution of a  action is adjusted using R, the 6 output of that action will also be updated to match.)None 8=>?@ACHV@*None&',=>?@ACEGHIMSUVX_`XreflexFThe monad for actions that manipulate a Spider timeline identified by xreflex is the old name for  reflex&The default, global Spider environment reflex.Designates the default, global Spider timelinereflex&Retrieve the current SpiderTimelineEnvreflexlStores all global data relevant to a particular Spider timeline; only one value should exist for each type xreflexA statically allocated  reflex Construct an # equivalent to that constructed by /g, but with no caching; if the computation function is very cheap, this is (much) more efficient than /reflex'A subscriber that never triggers other sreflex=Subscribe to an Event only for the duration of one occurrencereflex 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 joinsreflex*Propagate everything at the current heightreflex*Propagate everything at the current heightfreflex&Run an event action outside of a framewreflexCreate a new SpiderTimelineEnvyreflex*Pass a new timeline to the given function.zreflexfRun an action affecting the global Spider timeline; this will be guarded by a mutex for that timeline{reflexcRun an action affecting a given Spider timeline; this will be guarded by a mutex for that timeline      !"#$%&'()*+,-./0123456789:;<=AD@?>BCEFGHIJKMONLPQRSTUVWXYZ[^]_\`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}      !"#$%&'()*+,-./0123456789:;<=AD@?>BCEFGHIJKMONLPQRSTUVWXYZ[^]_\`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}5Noned  wyz{  z{wy+None@Aq9reflexGiven a Dynamic of network-creating actions, create a network that is recreated whenever the Dynamic updates. The returned Event of network results occurs when the Dynamic does. Note: Often, the type aj is an Event, in which case the return value is an Event-of-Events that would typically be flattened (via ).reflexGiven an initial network and an Event 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 af is an Event, in which case the return value is a Dynamic-of-Events that would typically be flattened.reflexXRender a placeholder network to be shown while another network is not yet done building6Noneq,%Implementation of MonadBehaviorWriterNone&'1=?@AHMSVXureflexA basic implementation of N.reflexRun a [ action. The behavior writer output will be provided along with the result of the action.reflex$Map a function over the output of a .1Nonevb STYZ[\]_`abcdwxyz{     !" #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;IJKLMNOQRSTUVWXYfgklmnopqrs*+,-./0123456789:WXYZ[\rstuvwx wyz{-None@ANXreflexmBuild 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")]) sortEventreflex6Function to render the content for each key/value pairreflex=The sortable list with an initial ordering determined by the Map keys in ascending orderreflex.An event carrying a sort function for the list.NoneNX789:;<=>??@ABCDDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx9:;y=>z{|}~  : <                                          1!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijjklmnopqrstuvwxyz{|}~!"#$3                              !!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(")"*"+#,#,#-#.#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S###$T$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m%n%n%o%p%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''(((((((((((((((((((((((((((()))))))))))**********************2****************************** * * * * * * * *********************** *!*"*"*#*$*%*%*&*'*(*)***+*,*-*.*/*0*0*1*2*3*3*4*5*6*7*8*8*9*:*;*<*<*=*>*?*?*@*A*B*B*C*D*D*E*F*F*G*H*H*I*J*K*L*L*M*M*N*N*O*P*Q*R*R*S*T*U*V*W*X*Y*Z*[*\*\*]*^*_*_*`*a*b*c*d*d*e*f*g*h*h*i*j*k*l*m*n*o*p*q*r*r*s*t*u*v*w*x*y*z*{*|*}*~*~**********#*#***!*!****************"*"*************************************************************************************y**2**)*+*.*/***********************=**********,******* * * * *>* *-******************* *!*"*#*$*%*&*'*(*)***+*,**-*.*/*0****1*2*3*4*5*6*7*8*9*:*;****<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*|*}*~*******+++,,,,,,,,,,,,,,,,,,,,,,,,,,,-......./::      !"#$%&'()*+,-.}/0123456789::;;<=>?@ABCDEFGyHHIJKJLMNOPQR"STUV#W#X#Y#Z#[#\#]#^_`a&b&c&dereflex-0.5-inplaceData.FastWeakBagData.Functor.Misc Data.Map.Misc Data.WeakBagReflex.FastWeakReflex.FunctorMaybeReflex.Patch.ClassReflex.Patch.IntMapData.FastMutableIntMapReflex.Patch.MapReflex.Patch.DMapReflex.Patch.MapWithMoveReflex.Patch.DMapWithMove Reflex.Patch Reflex.ClassReflex.Host.ClassReflex.EventWriter.ClassReflex.DynamicWriter.ClassReflex.Dynamic.UniqReflex.DynamicReflex.Dynamic.THReflex.BehaviorWriter.ClassReflex.Adjustable.ClassData.AppendMapReflex.PostBuild.ClassReflex.Collection Reflex.PureReflex.Query.ClassReflex.Requester.ClassReflex.TriggerEvent.ClassReflex.PerformEvent.ClassReflex.TriggerEvent.Base Reflex.TimeReflex.Requester.BaseReflex.ProfiledReflex.PostBuild.BaseReflex.PerformEvent.BaseReflex.EventWriter.BaseReflex.Query.BaseReflex.DynamicWriter.BaseReflex.NotReady.ClassReflex.Spider.InternalReflex.NetworkReflex.BehaviorWriter.BaseReflex.Widget.BasicReflex.WorkflowMap MapWithMoveReflexSpider performEventReflex.EventWriter Reflex.SpiderReflex.DynamicWriterFastWeakBagTicket FastWeakBag_weakBag_childreninsertemptyisEmptytraverseremove ComposeMaybegetComposeMaybe EitherTagLeftTagRightTagWrapArgConst2unConst2 dmapToMap dmapToIntMap dmapToMapWith mapToDMapmapWithFunctorToDMapintMapWithFunctorToDMapweakenDMapWithmapKeyValuePairsMonotoniccombineDMapsWithKey dmapToThese eitherToDSum dsumToEither sequenceDmapwrapDMap rewrapDMap unwrapDMapunwrapDMapMaybeextractFunctorDMap$fGComparekConst2 $fGEqkConst2$fShowTagkConst2f$fGShowkConst2$fGCompareTYPEWrapArg$fGEqTYPEWrapArg$fShowTagTYPEEitherTagIdentity$fGShowkEitherTag$fGComparekEitherTag$fGEqkEitherTag$fShowComposeMaybe$fEqComposeMaybe$fOrdComposeMaybe$fFunctorComposeMaybe$fOrdEitherTag $fEqEitherTag$fShowEitherTag $fReadWrapArg $fShowWrapArg $fOrdWrapArg $fEqWrapArg $fReadConst2 $fShowConst2 $fOrdConst2 $fEqConst2 diffMapNoEqdiffMapapplyMapmapPartitionEithersapplyMapKeysSet WeakBagTicketWeakBag singletonFastWeakFastWeakTicketgetFastWeakTicketValuegetFastWeakValuegetFastWeakTicketmkFastWeakTicketgetFastWeakTicketWeak emptyFastWeak FunctorMaybe fmapMaybe$fFunctorMaybeIntMap$fFunctorMaybeMap$fFunctorMaybe[]$fFunctorMaybeMaybePatch PatchTargetapply applyAlwayscomposePatchFunctions$fPatchIdentity PatchIntMapmapIntMapPatchWithKeytraverseIntMapPatchWithKeypatchIntMapNewElementspatchIntMapNewElementsMap getDeletions$fSemigroupPatchIntMap$fPatchPatchIntMap$fFunctorPatchIntMap$fFoldablePatchIntMap$fTraversablePatchIntMap$fMonoidPatchIntMapFastMutableIntMapnewnewEmptylookupforIntersectionWithImmutable_for_sizegetFrozenAndClear applyPatchPatchMap unPatchMappatchMapNewElementspatchMapNewElementsMap$fFunctorPatchMap$fMonoidPatchMap$fSemigroupPatchMap$fPatchPatchMap$fShowPatchMap$fReadPatchMap $fEqPatchMap $fOrdPatchMap PatchDMap unPatchDMap mapPatchDMaptraversePatchDMaptraversePatchDMapWithKeyweakenPatchDMapWithpatchDMapToPatchMapWithconst2PatchDMapWithconst2IntPatchDMapWith$fPatchPatchDMap$fMonoidPatchDMap$fSemigroupPatchDMapFixup Fixup_Delete Fixup_UpdateToFrom From_Insert From_Delete From_MoveNodeInfo_nodeInfo_from _nodeInfo_toPatchMapWithMovepatchMapWithMovepatchMapWithMoveInsertAllunPatchMapWithMove insertMapKey moveMapKey swapMapKey deleteMapKeyunsafePatchMapWithMovepatchMapWithMoveNewElementspatchMapWithMoveNewElementsMappatchThatSortsMapWithpatchThatChangesAndSortsMapWithpatchThatChangesMapnodeInfoMapFromnodeInfoMapMFrom nodeInfoSetTo$fMonoidPatchMapWithMove$fPatchPatchMapWithMove$fSemigroupPatchMapWithMove $fShowFrom $fReadFrom$fEqFrom $fOrdFrom $fFunctorFrom$fFoldableFrom$fTraversableFrom$fShowNodeInfo$fReadNodeInfo $fEqNodeInfo $fOrdNodeInfo$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fShowPatchMapWithMove$fEqPatchMapWithMove$fOrdPatchMapWithMove$fFunctorPatchMapWithMove$fFoldablePatchMapWithMove$fTraversablePatchMapWithMovePair1PatchDMapWithMovevalidPatchDMapWithMove$validationErrorsForPatchDMapWithMove insertDMapKey moveDMapKey swapDMapKey deleteDMapKeyunPatchDMapWithMoveunsafePatchDMapWithMovepatchDMapWithMovemapPatchDMapWithMovetraversePatchDMapWithMove traversePatchDMapWithMoveWithKeynodeInfoMapFromMweakenPatchDMapWithMoveWith'patchDMapWithMoveToPatchMapWithMoveWithconst2PatchDMapWithMoveWithgetDeletionsAndMoves$fPatchPatchDMapWithMove$fMonoidPatchDMapWithMove$fEqPatchDMapWithMove$fSemigroupPatchDMapWithMove AdditivePatchunAdditivePatchAdditiveGroupnegateG~~$fPatchAdditivePatch AccumulatoraccumaccumM accumMaybe accumMaybeMmapAccum mapAccumM mapAccumMaybemapAccumMaybeMEventSelectorInt selectInt EventSelectorselect MonadHoldholdholdDynholdIncremental buildDynamicheadE MonadSamplesampleBehaviorEventDynamic IncrementalPushMPullMneverconstantpush pushCheappullmergefanswitch coincidencecurrentupdatedunsafeBuildDynamicunsafeBuildIncrementalmergeIncrementalmergeIncrementalWithMovecurrentIncrementalupdatedIncrementalincrementalToDynamicbehaviorCoercion eventCoerciondynamicCoercionmergeIntIncrementalfanIntmergeIntcoerceBehavior coerceEvent coerceDynamic unsafeDynamicconstDynaccumIncrementalaccumMIncrementalaccumMaybeIncrementalaccumMaybeMIncrementalmapAccumIncrementalmapAccumMIncrementalmapAccumMaybeIncrementalmapAccumMaybeMIncremental slowHeadE pushAlwaysfforffor2ffor3 fforMaybeffilter filterLeft filterRighttagtagMaybeattach attachWithattachWithMaybetailE headTailE takeWhileEtakeWhileJustE dropWhileEtakeDropWhileJustEsplitE traceEventtraceEventWith mergeWithleftmost mergeListunsafeMapIncrementalmergeMap mergeIntMapmergeMapIncrementalmergeIntMapIncrementalmergeMapIncrementalWithMove fanEitherfanThesefanMap switchHoldswitchHoldPromptlyswitchHoldPromptOnlycoincidencePatchMapcoincidencePatchIntMapcoincidencePatchMapWithMoveswitchHoldPromptOnlyIncrementalgateswitcherzipDyn zipDynWithdistributeDMapOverDynPuredistributeListOverDyndistributeListOverDynWith differencealignEventWithMaybefilterEventKey factorEventaccumDyn accumMDyn accumMaybeDynaccumMaybeMDyn mapAccumDyn mapAccumMDynmapAccumMaybeDynmapAccumMaybeMDynaccumBaccumMB accumMaybeB accumMaybeMB mapAccumB mapAccumMBmapAccumMaybeBmapAccumMaybeMB mapAccum_mapAccumMaybe_ mapAccumM_mapAccumMaybeM_zipListWithEventnumberOccurrencesnumberOccurrencesFromnumberOccurrencesFrom_<@><@pushAlwaysCheapfmapMaybeCheapfforMaybeCheap fforCheap fmapCheaptagCheapmergeWithCheapmergeWithCheap' appendEventsonceE sequenceTheseswitchPromptlyswitchPromptOnly$fMonoidDynamic$fSemigroupDynamic$fIsStringDynamic $fAlignEvent $fMonoidEvent$fSemigroupEvent $fPlusEvent$fFunctorMaybeEvent$fFunctorEvent $fBindEvent $fApplyEvent $fAltEvent$fSemigroupBehavior $fNumBehavior$fMonoidBehavior$fMonadBehavior$fIsStringBehavior$fFunctorBehavior$fFractionalBehavior$fBindBehavior$fApplyBehavior$fApplicativeBehavior$fMonadHoldktContT$fMonadSamplektContT$fMonadHoldktRWST$fMonadSamplektRWST$fMonadHoldktExceptT$fMonadSamplektExceptT$fMonadHoldktStateT$fMonadSamplektStateT$fMonadHoldktWriterT$fMonadSamplektWriterT$fMonadHoldktReaderT$fMonadSamplektReaderT$fDefaultDynamic$fAccumulatorktEvent$fAccumulatorktBehavior$fAccumulatorktDynamicMonadReflexHost 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 EventWriter tellEvent$fEventWritertwReaderTMonadDynamicWritertellDyn$fMonadDynamicWritertwReaderT UniqDynamic uniqDynamicfromUniqDynamicalreadyUniqDynamic$fMonadUniqDynamic$fApplicativeUniqDynamic$fFunctorUniqDynamic$fAccumulatorTYPEtUniqDynamicIsHList HListElemstoHList fromHListAllAreFunctors FunctorListtoFHList fromFHListRebuildSortedHListrebuildSortedFHListrebuildSortedHListHListPtrHHeadPtrHTailPtrFHListFHNilFHConsHListHNilHConsDemuxmapDynMforDynM holdUniqDyn holdUniqDynByimprovingMaybescanDyn scanDynMaybefoldDynfoldDynM foldDynMaybe foldDynMaybeMcounttoggle switchDynswitchPromptlyDyn splitDynPuredistributeMapOverDynPuredistributeListOverDynPurejoinDynThroughMaptraceDyn traceDynWithtagPromptlyDynattachPromptlyDynattachPromptlyDynWithattachPromptlyDynWithMaybemaybeDyn eitherDyn factorDyndemuxdemuxeddistributeFHListOverDynPurecollectDynPuremapDynforDynsplitDyn mconcatDyndistributeDMapOverDyn combineDynapDyn getDemuxeddistributeFHListOverDyn collectDyntagDyn attachDyn attachDynWithattachDynWithMaybejoinDynnubDynuniqDyn uniqDynBy $fHBuild'l->$fHBuild'lHList$fGComparekHListPtr$fGEqkHListPtr$fRebuildSortedHList:$fRebuildSortedHList[]$fAllAreFunctorsaf:$fAllAreFunctorsaf[]$fIsHList(,,,,,)$fIsHList(,,,) $fIsHList(,) $fOrdHListPtr $fEqHListPtrqDynPureunqDyn mkDynPureqDynmkDynMonadBehaviorWriter tellBehavior$fMonadBehaviorWritertwReaderT MonadAdjust AdjustablerunWithReplacetraverseIntMapWithKeyWithAdjusttraverseDMapWithKeyWithAdjust%traverseDMapWithKeyWithAdjustWithMovesequenceDMapWithAdjustsequenceDMapWithAdjustWithMovemapMapWithAdjustWithMove$fAdjustabletReaderT AppendMap _unAppendMapnonEmptyDeletemapMaybeNoNullshowTree showTreeWith$fDefaultMonoidalMap$fAdditiveMonoidalMap$fGroupMonoidalMap$fFunctorMaybeMonoidalMap PostBuild getPostBuild$fPostBuildtStateT$fPostBuildtStateT0$fPostBuildtReaderTlistHoldWithKey listWithKey listWithKey'listWithKeyShallowDifflistViewWithKeyselectViewListWithKeyselectViewListWithKey_list simpleListPure unBehaviorunEvent unDynamic unIncremental$fMonadHoldTYPEPure->$fMonadSampleTYPEPure->$fMonadDynamic$fApplicativeDynamic$fFunctorDynamic$fReflexTYPEPure MonadQuerytellQueryIncrementalaskQueryResultqueryIncremental SelectedCountunSelectedCount QueryMorphism_queryMorphism_mapQuery_queryMorphism_mapQueryResultQuery QueryResultcropmapQuerymapQueryResultcombineSelectedCounts tellQueryDynqueryDyn$fQueryMonoidalMap$fCategoryTYPEQueryMorphism$fAdditiveSelectedCount$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$fTriggerEventtStateT$fTriggerEventtStateT0$fTriggerEventtReaderT PerformEvent Performable performEvent_performEventAsync$fPerformEventtReaderT TriggerEventTunTriggerEventTEventTriggerRefunEventTriggerRefTriggerInvocationrunTriggerEventT askEvents$fSemigroupTriggerEventT$fMonoidTriggerEventT$fAdjustabletTriggerEventT$fMonadHoldTYPEtTriggerEventT$fMonadSampleTYPEtTriggerEventT$fMonadAtomicRefTriggerEventT$fMonadRefTriggerEventT$fTriggerEventtTriggerEventT($fMonadReflexCreateTriggertTriggerEventT$fPostBuildtTriggerEventT$fPerformEventtTriggerEventT$fPrimMonadTriggerEventT$fMonadTransTriggerEventT$fFunctorTriggerEventT$fApplicativeTriggerEventT$fMonadTriggerEventT$fMonadFixTriggerEventT$fMonadIOTriggerEventT$fMonadExceptionTriggerEventT"$fMonadAsyncExceptionTriggerEventTTickInfo_tickInfo_lastUTC _tickInfo_n_tickInfo_alreadyElapsed tickLossytickLossyFromPostBuildTime tickLossyFromtickLossyFrom' clockLossygetCurrentTickdelaypoissonLossyFrom poissonLossyinhomogeneousPoissonFrominhomogeneousPoissondebouncebatchOccurrencesthrottle $fEqTickInfo $fOrdTickInfo$fShowTickInfotickInfo_alreadyElapsedtickInfo_lastUTC tickInfo_n RequesterT unRequesterTRequesterDataKey RequesterDatasingletonRequesterDatarequesterDataToListtraverseRequesterDataforRequesterData runRequesterTrunWithReplaceRequesterTWith-traverseIntMapWithKeyWithAdjustRequesterTWith+traverseDMapWithKeyWithAdjustRequesterTWith$fMyTagTypeOffsetMulti3$fMyTagTypeOffsetMulti2$fMyTagTypeOffsetMulti$fMyTagTypeOffsetSingle$fGCompareTYPEMyTag$fGEqTYPEMyTag$fGCompareTYPEMyTagWrap$fGEqTYPEMyTagWrap$fAdjustabletRequesterT$fMonadReaderrRequesterT%$fMonadReflexCreateTriggertRequesterT$fMonadRefRequesterT$fPerformEventtRequesterT$fMonadTransRequesterT$fRequestertRequesterT$fSemigroupRequesterT$fMonoidRequesterT $fShowMyTag $fEqMyTag $fOrdMyTag $fEnumMyTag$fShowMyTagWrap $fEqMyTagWrap$fOrdMyTagWrap$fEnumMyTagWrap$fFunctorRequesterT$fApplicativeRequesterT$fMonadRequesterT$fMonadFixRequesterT$fMonadIORequesterT$fMonadExceptionRequesterT$fMonadAsyncExceptionRequesterT$fTriggerEventRequesterT$fPostBuildRequesterT$fMonadHoldRequesterT$fMonadSampleRequesterT ProfiledM runProfiledMCostCentreTree_costCentreTree_ownEntries!_costCentreTree_cumulativeEntries_costCentreTree_childrenProfiledTimeline profilingDatagetCostCentreStacktoCostCentreTreegetCostCentreTreeformatCostCentreTreeshowProfilingDatawriteProfilingData profileEvent$fMonoidCostCentreTree$fSemigroupCostCentreTree)$fMonadReadEventProfiledTimelineProfiledM*$fMonadReflexHostProfiledTimelineProfiledM$fPrimMonadProfiledM.$fMonadSubscribeEventProfiledTimelineProfiledM$fReflexHostProfiledTimeline$fMonadReaderrProfiledM3$fMonadReflexCreateTriggerProfiledTimelineProfiledM$fMonadRefProfiledM'$fPerformEventProfiledTimelineProfiledM$fMonadIOProfiledM$fMonadTransProfiledM*$fMonadSampleTYPEProfiledTimelineProfiledM($fMonadHoldTYPEProfiledTimelineProfiledM$fReflexTYPEProfiledTimeline$fShowCostCentreTree$fEqCostCentreTree$fOrdCostCentreTree$fFunctorProfiledM$fApplicativeProfiledM$fMonadProfiledM$fMonadFixProfiledM$fMonadExceptionProfiledM$fMonadAsyncExceptionProfiledM PostBuildT unPostBuildT runPostBuildTmapIntMapWithAdjustImplmapDMapWithAdjustImpl$fMonadTransControlPostBuildT$fAdjustabletPostBuildT$fMonadAtomicRefPostBuildT$fMonadRefPostBuildT$fTriggerEventtPostBuildT%$fMonadReflexCreateTriggertPostBuildT$fPerformEventtPostBuildT$fMonadHoldTYPEtPostBuildT$fMonadSampleTYPEtPostBuildT$fPostBuildtPostBuildT$fPrimMonadPostBuildT$fSemigroupPostBuildT$fMonoidPostBuildT$fFunctorPostBuildT$fApplicativePostBuildT$fMonadPostBuildT$fMonadFixPostBuildT$fMonadIOPostBuildT$fMonadTransPostBuildT$fMonadExceptionPostBuildT$fMonadAsyncExceptionPostBuildT PerformEventTunPerformEventT FireCommandrunFireCommandhostPerformEventT$fMonadAtomicRefPerformEventT$fMonadRefPerformEventT$fMonadHoldTYPEtPerformEventT$fMonadSampleTYPEtPerformEventT($fMonadReflexCreateTriggertPerformEventT$fAdjustabletPerformEventT$fPerformEventtPerformEventT$fPrimMonadPerformEventT$fSemigroupPerformEventT$fMonoidPerformEventT$fMonadExceptionPerformEventT$fMonadIOPerformEventT$fMonadFixPerformEventT$fMonadPerformEventT$fApplicativePerformEventT$fFunctorPerformEventT EventWriterTunEventWriterTrunEventWriterTrunWithReplaceEventWriterTWith&sequenceDMapWithAdjustEventWriterTWithwithEventWriterTmapEventWriterT$fGCompareTYPETellId$fGEqTYPETellId$fPrimMonadEventWriterT"$fMonadDynamicWritertwEventWriterT$fMonadQuerytqEventWriterT'$fMonadReflexCreateTriggertEventWriterT$fMonadAtomicRefEventWriterT$fMonadRefEventWriterT$fMonadReaderrEventWriterT$fTriggerEventtEventWriterT$fPostBuildtEventWriterT$fPerformEventtEventWriterT$fRequestertEventWriterT$fAdjustabletEventWriterT$fMonadHoldTYPEtEventWriterT$fMonadSampleTYPEtEventWriterT$fMonadTransEventWriterT$fEventWritertwEventWriterT $fShowTellId $fEqTellId $fOrdTellId $fEnumTellId$fFunctorEventWriterT$fApplicativeEventWriterT$fMonadEventWriterT$fMonadFixEventWriterT$fMonadIOEventWriterT$fMonadExceptionEventWriterT!$fMonadAsyncExceptionEventWriterTQueryTunQueryT runQueryT withQueryT dynWithQueryT$fMonadDynamicWritertwQueryT$fEventWritertwQueryT$fRequestertQueryT$fMonadQuerytqQueryT$fSemigroupQueryT$fMonoidQueryT!$fMonadReflexCreateTriggertQueryT$fMonadRefQueryT$fPerformEventtQueryT$fTriggerEventtQueryT$fMonadAsyncExceptionQueryT$fPostBuildtQueryT$fPrimMonadQueryT$fMonadTransQueryT$fAdjustabletQueryT$fFunctorQueryT$fApplicativeQueryT $fMonadQueryT$fMonadExceptionQueryT$fMonadFixQueryT$fMonadIOQueryT$fMonadAtomicRefQueryT$fMonadSampleQueryT$fMonadHoldQueryTDynamicWriterTunDynamicWriterTrunDynamicWriterTwithDynamicWriterT$fEventWritertwDynamicWriterT$fMonadQuerytqDynamicWriterT$fRequestertDynamicWriterT$fAdjustabletDynamicWriterT$fMonadStatesDynamicWriterT$fPostBuildtDynamicWriterT$fTriggerEventtDynamicWriterT$fPerformEventtDynamicWriterT$fMonadReaderrDynamicWriterT$$fMonadDynamicWritertwDynamicWriterT)$fMonadReflexCreateTriggertDynamicWriterT$fMonadAtomicRefDynamicWriterT$fMonadRefDynamicWriterT$fMonadTransDynamicWriterT$fFunctorDynamicWriterT$fApplicativeDynamicWriterT$fMonadDynamicWriterT$fMonadIODynamicWriterT$fMonadFixDynamicWriterT#$fMonadAsyncExceptionDynamicWriterT$fMonadExceptionDynamicWriterT$fMonadSampleDynamicWriterT$fMonadHoldDynamicWriterTNotReady notReadyUntilnotReady$fNotReadytTriggerEventT$fNotReadytRequesterT$fNotReadytPerformEventT$fNotReadytQueryT$fNotReadytDynamicWriterT$fNotReadytEventWriterT$fNotReadytPostBuildT$fNotReadytReaderTSpiderHostFramerunSpiderHostFrame SpiderHost unSpiderHostSpiderEventHandlespiderEventHandleSubscriptionspiderEventHandleValue RootTrigger SpiderPushMComputeM SpiderPullMLocalSpiderTimeline SpiderEnvSpiderTimelineSomeSwitchSubscribedHeightunHeightMerge_merge_parentsRef_merge_heightBagRef_merge_heightRef _merge_sub_merge_accumRefMergeDestroyFunc MergeInitFuncMergeUpdateFuncFanInt_fanInt_subscribers_fanInt_subscriptionRef_fanInt_occRefSomeResetCoincidenceCanTraceWeakListSomeAssignment SomeRootClear SomeIntClear SomeClearResultMDynunDynDynType UnsafeDynBuildDynHoldDyn CoincidencecoincidenceParentcoincidenceSubscribedCoincidenceSubscribed%coincidenceSubscribedCachedSubscribedcoincidenceSubscribedOccurrence coincidenceSubscribedSubscriberscoincidenceSubscribedHeightcoincidenceSubscribedOuter coincidenceSubscribedOuterParent coincidenceSubscribedInnerParentcoincidenceSubscribedWeakSelfSwitch switchParentswitchSubscribedSwitchSubscribed switchSubscribedCachedSubscribedswitchSubscribedOccurrenceswitchSubscribedHeightswitchSubscribedSubscribersswitchSubscribedOwnInvalidator"switchSubscribedOwnWeakInvalidatorswitchSubscribedBehaviorParentsswitchSubscribedParentswitchSubscribedCurrentParentswitchSubscribedWeakSelfFan fanParent fanSubscribed FanSubscribedfanSubscribedCachedSubscribedfanSubscribedOccurrencefanSubscribedSubscribersfanSubscribedParentFanSubscribedChildren_fanSubscribedChildren_list_fanSubscribedChildren_self_fanSubscribedChildren_weakSelf HeightBag_heightBag_size_heightBag_contentsMergeSubscribedParentWithMove+_mergeSubscribedParentWithMove_subscription"_mergeSubscribedParentWithMove_keyMergeSubscribedParentunMergeSubscribedParentEventMunEventM SomeMergeInitunSomeMergeInitSomeMergeUpdate_someMergeUpdate_update!_someMergeUpdate_invalidateHeight"_someMergeUpdate_recalculateHeight SomeDynInit SomeHoldInitRootrootOccurrencerootSubscribedrootInitRootSubscribedrootSubscribedKeyrootSubscribedCachedSubscribedrootSubscribedSubscribersrootSubscribedOccurrencerootSubscribedUninitrootSubscribedWeakSelf InvalidatorInvalidatorPullInvalidatorSwitchPull pullValue pullComputePullSubscribedpullSubscribedValuepullSubscribedInvalidatorspullSubscribedOwnInvalidatorpullSubscribedParentsSomeBehaviorSubscribedBehaviorSubscribedBehaviorSubscribedHoldBehaviorSubscribedPull BehaviorM unBehaviorM BehaviorEnvHasSpiderTimelinespiderTimelineHasCurrentHeightgetCurrentHeight scheduleMergeDefergetDeferralQueueEventEnveventEnvAssignmentseventEnvHoldInitseventEnvDynInitseventEnvMergeUpdateseventEnvMergeInitseventEnvClearseventEnvIntClearseventEnvRootClearseventEnvCurrentHeighteventEnvResetCoincidenceseventEnvDelayedMergesSpiderTimelineEnv_spiderTimeline_lock_spiderTimeline_eventEnvGlobalHold holdValueholdInvalidators holdEvent holdParentdynamicCurrentdynamicUpdatedreadBehaviorTrackedEventSubscribedeventSubscribedHeightRefeventSubscribedRetained SubscribersubscriberPropagatesubscriberInvalidateHeightsubscriberRecalculateHeightCacheSubscribed_cacheSubscribed_subscribers_cacheSubscribed_parent_cacheSubscribed_occurrenceEventSubscription_eventSubscription_unsubscribe_eventSubscription_subscribedSpiderBehaviorunSpiderBehavior SpiderEvent unSpiderEvent SpiderDynamicunSpiderDynamicSpiderIncrementalunSpiderIncrementaldebugPropagatedebugInvalidateHeightdebugInvalidate showNodeId unsubscribesubscribeAndReadterminalSubscribersubscribeAndReadHead cacheEvent subscribewrap eventRoot eventNevereventFan eventSwitcheventCoincidence eventHoldeventDynsubscribeCoincidenceInnernewSubscriberHoldnewSubscriberFannewSubscriberSwitchnewSubscriberCoincidenceOuternewSubscriberCoincidenceInnerinvalidateSubscriberHeightrecalculateSubscriberHeight propagate propagateFasttoAnyeventSubscribedRooteventSubscribedNevereventSubscribedFaneventSubscribedSwitcheventSubscribedCoincidencegetEventSubscribedHeightsubscribeHoldEvent behaviorHoldbehaviorHoldIdentity behaviorConst behaviorPull behaviorDynreadHoldTrackedreadBehaviorUntracked dynamicHolddynamicHoldIdentity dynamicConst dynamicDyndynamicDynIdentityglobalSpiderTimelineEnv runEventM asksEventEnvdeferputCurrentHeight scheduleClearscheduleIntClearscheduleRootCleargetHoldEventSubscriptionheightBagEmpty heightBagSizeheightBagFromList heightBagAddheightBagRemove heightBagMaxheightBagVerifynewInvalidatorSwitchnewInvalidatorPull newMapDynunsafeNewIORefrunscheduleMerge' debugFinalizemkWeakPtrWithDebugwithIncreasedDepthtracePropagatetraceInvalidate traceWhen traceMWhenwhoCreatedIORefpropagateSubscriberHold runBehaviorMaskInvalidator askParentsRefaskBehaviorHoldInits getDynHoldzeroRefgetRootSubscribedcleanupRootSubscribedsubscribeRootSubscribed newFanIntunsafeNewFanIntgetFanSubscribedcleanupFanSubscribedsubscribeFanSubscribedgetSwitchSubscribedcleanupSwitchSubscribedsubscribeSwitchSubscribedgetCoincidenceSubscribedcleanupCoincidenceSubscribedsubscribeCoincidenceSubscribed mergeWithMove mergeCheapmergeCheapWithMoveinvalidateMergeHeightinvalidateMergeHeight'revalidateMergeHeightscheduleMergeSelfmergeSubscriber updateMerge mergeCheap' mergeIntCheap runHoldInitsinitHoldinitDyn newEventEnv clearEventEnvrunFrame zeroHeight invalidHeight succHeightinvalidateCoincidenceHeightupdateSwitchHeightrecalculateCoincidenceHeightcalculateSwitchHeightcalculateCoincidenceHeight invalidate newJoinDynmapDynamicSpiderholdSpiderEventMholdDynSpiderEventMholdIncrementalSpiderEventMbuildDynamicSpiderEventMunsafeNewSpiderTimelineEnvnewSpiderTimelinelocalSpiderTimelinewithSpiderTimeline runSpiderHostrunSpiderHostForTimelinenewEventWithTriggerIOnewFanEventWithTriggerIO$fMonadAtomicRefEventM$fMonadRefEventM$fMonadBehaviorM$fDeferSomeHoldInitBehaviorM$fGEqTYPESpiderTimelineEnv$fEqSpiderTimelineEnv!$fDeferSomeResetCoincidenceEventM$fDeferSomeRootClearEventM$fDeferSomeIntClearEventM$fDeferSomeClearEventM$fHasSpiderTimelineGlobal$fDeferSomeMergeInitEventM$fDeferSomeMergeUpdateEventM$fDeferSomeDynInitEventM$fDeferSomeHoldInitEventM$fDeferSomeAssignmentEventM$fHasCurrentHeightxEventM#$fMonadHoldTYPESpiderTimelineEventM%$fMonadSampleTYPESpiderTimelineEventM&$fHasSpiderTimelineLocalSpiderTimeline*$fMonadSampleTYPESpiderTimelineSpiderPullM$fReflexTYPESpiderTimeline($fMonadHoldTYPESpiderTimelineSpiderPushM*$fMonadSampleTYPESpiderTimelineSpiderPushM$fMonadAtomicRefSpiderHost$fMonadRefSpiderHost$fMonadSpiderHost2$fMonadReflexCreateTriggerSpiderTimelineSpiderHost)$fMonadSampleTYPESpiderTimelineSpiderHost$fPrimMonadSpiderHostFrame$fMonadAtomicRefSpiderHostFrame$fMonadRefSpiderHostFrame'$fNotReadySpiderTimelineSpiderHostFrame$fMonadSpiderHostFrame-$fMonadSubscribeEventSpiderTimelineSpiderHost7$fMonadReflexCreateTriggerSpiderTimelineSpiderHostFrame$fReflexHostSpiderTimeline2$fMonadSubscribeEventSpiderTimelineSpiderHostFrame,$fMonadHoldTYPESpiderTimelineSpiderHostFrame.$fMonadSampleTYPESpiderTimelineSpiderHostFrame'$fMonadHoldTYPESpiderTimelineSpiderHost)$fMonadReflexHostSpiderTimelineSpiderHost'$fMonadReadEventSpiderTimelineReadPhase&$fMonadHoldTYPESpiderTimelineReadPhase($fMonadSampleTYPESpiderTimelineReadPhase$fFunctorEventM$fApplicativeEventM $fMonadEventM$fMonadIOEventM$fMonadFixEventM$fMonadExceptionEventM$fMonadAsyncExceptionEventM$fShowHeightBag$fReadHeightBag $fEqHeightBag$fOrdHeightBag $fShowHeight $fReadHeight $fEqHeight $fOrdHeight$fBoundedHeight$fFunctorBehaviorM$fApplicativeBehaviorM$fMonadIOBehaviorM$fMonadFixBehaviorM$fFunctorSpiderPullM$fApplicativeSpiderPullM$fMonadSpiderPullM$fMonadIOSpiderPullM$fMonadFixSpiderPullM$fFunctorSpiderPushM$fApplicativeSpiderPushM$fMonadSpiderPushM$fMonadIOSpiderPushM$fMonadFixSpiderPushM$fFunctorSpiderHost$fApplicativeSpiderHost$fMonadFixSpiderHost$fMonadIOSpiderHost$fMonadExceptionSpiderHost$fMonadAsyncExceptionSpiderHost$fFunctorSpiderHostFrame$fApplicativeSpiderHostFrame$fMonadFixSpiderHostFrame$fMonadIOSpiderHostFrame$fMonadExceptionSpiderHostFrame$$fMonadAsyncExceptionSpiderHostFrame$fFunctorReadPhase$fApplicativeReadPhase$fMonadReadPhase$fMonadFixReadPhase networkView networkHold untilReadyBehaviorWriterTunBehaviorWriterTrunBehaviorWriterTwithBehaviorWriterT$fAdjustabletBehaviorWriterT$fMonadQuerytqBehaviorWriterT$fRequestertBehaviorWriterT$fMonadStatesBehaviorWriterT$fPostBuildtBehaviorWriterT$fTriggerEventtBehaviorWriterT$fPerformEventtBehaviorWriterT$fMonadReaderrBehaviorWriterT&$fMonadBehaviorWritertwBehaviorWriterT*$fMonadReflexCreateTriggertBehaviorWriterT$fMonadAtomicRefBehaviorWriterT$fMonadRefBehaviorWriterT$fMonadTransBehaviorWriterT$fFunctorBehaviorWriterT$fApplicativeBehaviorWriterT$fMonadBehaviorWriterT$fMonadIOBehaviorWriterT$fMonadFixBehaviorWriterT$$fMonadAsyncExceptionBehaviorWriterT$fMonadExceptionBehaviorWriterT$fMonadSampleBehaviorWriterT$fMonadHoldBehaviorWriterT sortableListWorkflow unWorkflowworkflow workflowView mapWorkflowmapWorkflowCheapbase Data.EitherEitherRdependent-sum-0.4-febab831cbd397d1e892acc7bab08399f3e743971860f4c78daa00abd99ffc7fData.Dependent.SumDSumVdependent-map-0.2.4.0-99670a723517ce80f5856426449ef46c7362a39e132bda8ed2b8505819f4f977Data.Dependent.Map.InternalDMapcontainers-0.6.0.1Data.Map.InternalData.IntMap.InternalIntMapGHC.BaseFunctorData.Functor.IdentityIdentityghc-prim GHC.ClassesEq mapEitherData.Set.InternalSetkeysSetGHC.WeakWeak GHC.MaybeMaybeJustid SemigroupNothingfmapdeletemplus ApplicativeMonadData.Dependent.Map Data.SomeSomeMonoidData.Type.CoercionCoercionliftA2liftA3LeftRight GHC.TypesTrueFalseStringLthese-0.7.5-0280f2b690eb7dd9ae60831f17e7049f0b081831a3c72a84843286372918ca1d Data.TheseThisThatThesemappendTsemigroupoids-5.3.2-14cfac641ae01584ba2fe51bc7d75b14668bd3b9663a64b2835019f6ffca8dd9Data.Functor.PluszeroDoubleFloatUnqDynreturn\monoidal-containers-0.4.0.0-302e1fc240334c0cc9365ecae165b3f83983109dac781e5371c44c5e29f4041fData.Map.MonoidalvalidmaxViewWithKeyminViewWithKeymaxViewminViewupdateMaxWithKeyupdateMinWithKey updateMax updateMin deleteFindMax deleteFindMin deleteMax deleteMinfindMaxfindMindeleteAtupdateAtelemAt findIndex lookupIndexisProperSubmapOfByisProperSubmapOf isSubmapOfBy isSubmapOf splitRoot splitLookupsplitmapEitherWithKeymapMaybeWithKeymapMaybepartitionWithKey partition filterWithKeyfilterfromDistinctAscListfromAscListWithKeyfromAscListWith fromAscList toDescList toAscListfromListWithKey fromListWithfromListtoListfromSet foldlWithKey' foldrWithKey'foldl'foldr'foldMapWithKey foldlWithKey foldrWithKeyfoldlfoldrmapKeysMonotonic mapKeysWithmapKeysmapAccumRWithKeymapAccumWithKeytraverseWithKey mapWithKeymap mergeWithKeyintersectionWithKeyintersectionWithdifferenceWithKeydifferenceWith unionsWith unionWithKey unionWithalterupdateLookupWithKey updateWithKeyupdate adjustWithKeyadjustinsertLookupWithKey insertWithKey insertWithlookupGElookupLElookupGTlookupLTnull\\!keyselemsassocsfindWithDefault notMembermember MonoidalMapgetMonoidalMapGHC.EnumEnumpredOMemoTrie-0.6.9-1f424566f35f4c19efb3a39d7593f3240e032aacbcbaef002483392af072f9c8 Data.MemoTrieHasTrieIOControl.Concurrent.ChanChanMyTagRprim-uniq-0.1.0.1-782faf4a2e73dbafeb58d2370f7bcf09625c42b9531ed8d6bb19f79740ac8ee9Unsafe.Unique.TagTagBehavior_ProfiledunBehavior_ProfiledEvent_ProfiledunEvent_ProfiledDynamic_ProfiledunDynamic_ProfiledIncremental_ProfiledunIncremental_Profiledtransformers-0.5.5.0Control.Monad.Trans.Class MonadTransTellIdtellId(sequenceIntMapWithAdjustEventWriterTWith