+      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe !"'+>IN      None!"*+34579=>CDIKLMNU- Tag type for  to use it as a .=A class for values that combines filtering and mapping using .(Combined mapping and filtering function.kCreate a new Behavior whose value will initially be equal to the given value and will be updated whenever the given Event occurs. The update takes effect immediately after the Event occurs; if the occurrence that sets the Behavior (or one that is simultaneous with it) is used to sample the Behavior, it will see the *old* value of the Behavior, not the new one.%Get the current value in the BehaviorA container for a value that can change over time. Behaviors can be sampled at will, but it is not possible to be notified when they changeA stream of occurrences. During any given frame, an Event is either occurring or not occurring; if it is occurring, it will contain a value of the given type (its "occurrence type") =A monad for doing complex push-based calculations efficiently!=A monad for doing complex pull-based calculations efficiently"An Event with no occurrences#1Create a Behavior that always has the given value$Create an Event from another Event; the provided function can sample Behaviors and hold Events, and use the results to produce a occurring (Just) or non-occurring (Nothing) result%{Create a Behavior by reading from other Behaviors; the result will be recomputed whenever any of the read Behaviors changes&Merge a collection of events; the resulting Event will only occur if at least one input event is occuring, and will contain all of the input keys that are occurring simultaneously'Efficiently fan-out an event to many destinations. This function should be partially applied, and then the result applied repeatedly to create child events(RCreate an Event that will occur whenever the currently-selected input Event occurs)Create an Event that will occur whenever the input event is occurring and its occurrence value, another Event, is also occurring*FCreate an Event from another Event. The provided function can sample  s and hold s.+Flipped version of .,Flipped version of .-6Filter 'f a' using the provided predicate. Relies on ,.. Create a new  by combining each occurence with the next value of the list using the supplied function. If the list runs out of items, all subsequent  occurrences will be ignored./%Replace each occurrence value of the  with the value of the  at the time of that occurrence.0 Create a new & that combines occurences of supplied  with the current value of the .1 Create a new  that occurs when the supplied 7 occurs by combining it with the current value of the .2 Create a new < by combining each occurence with the current value of the H. The occurrence is discarded if the combining function returns Nothing3 Alias for 44 Create a new : that only occurs on the first occurence of the supplied .5 Create a new = that occurs on all but the first occurence of the supplied .6Create a tuple of two @s with the first one occuring only the first time the supplied @ occurs and the second occuring on all but the first occurence.7Split the supplied  into two individual Gs occuring at the same time with the respective values from the tuple.8Print the supplied  and the value of the ! on each occurence. This should only be used for debugging.JNote: As with Debug.Trace.trace, the message will only be printed if the  is actually used.9DPrint the output of the supplied function on each occurence 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.:Convert  to a  . Inverse of ;.;Convert  to  . Inverse of :.<Extract the values of a  of s.= 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 .? 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.@ 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.A 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 occuring at that time.B 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 occuring at that time.CSplit the event into an 4 that allows efficient selection of the individual s.DSwitches to the new event whenever it receives one; the new event is used immediately, on the same frame that it is switched toE Create a new " that only occurs if the supplied  occurs and the " is true at the time of occurence.FrCreate a new behavior given a starting behavior and switch to a the behvior carried by the event when it fires.O !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_6 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFO"#$ %!&'()_^]\[ZYXWVUT*+SRQPO,-NM./0123456789LKJI:;<=>H?@ABCDGEF< "#$ %!&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_None!"'(*+34579=>CDIKLMNUc2Represents a time changing value together with an  that can efficiently detect when the underlying Dynamic has a particular value. This is useful for representing data like the current selection of a long list.Semantically, > getDemuxed (demux d) k === mapDyn (== k) d However, the when getDemuxed is used multiple times, the complexity is only  O(log(n)), rather than O(n) for mapDyn.duA container for a value that can change over time and allows notifications on changes. Basically a combination of a  and an L, with a rule that the Behavior will change if and only if the Event fires. Although Dynamic logically has a  instance, currently it can't be implemented without potentially requiring the mapped function to be evaluated twice. Instead, you can use n, which runs in a ' instance, to achieve the same result.i Extract the  of a d.j Extract the  of the d.kd" with the constant supplied value.l Create a d6 using the initial value that changes every time the  occurs.m Create a new d; that only signals changes if the values actually changed.nMap a function over a d.oFlipped version of n.pMap a monadic function over a dC. The only monadic action that the given function can perform is .q Create a d6 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 .r Create a d6 using the initial value and change it each time the U occurs using a monadic folding function on the previous value and the value of the .u Create a new d# that counts the occurences of the .v Create a new d> using the initial value that flips its value every time the  occurs.wSwitches to the new A whenever it receives one. Switching occurs *before* the inner  fires - so if the dv changes and both the old and new inner Events fire simultaneously, the output will fire with the value of the *new* .x Split the d into two d2s, each taking the respective value of the tuple.y Merge the d values using their  instance.z Create a d with a  of values out of a  of Dynamic values.{ Merge two d7s into a new one using the provided function. The new d2 changes its value each time one of the original ds changes its value.|Join a nested d into a new d" that has the value of the inner d.} Combine a d of a  of d s into a d! with the current values of the d s in a map.~Print the value of the dE on each change and prefix it 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.HPrint the result of applying the provided function to the value of the d on each change. 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.Replace the value of the  with the current value of the d each time the  occurs.ENote: `tagDyn d e` differs from `tag (current d) e` in the case that e" is firing at the same time that d5 is changing. With `tagDyn d e`, the *new* value of d will replace the value of eM, 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 d, because that would mean its value depends on itself. When creating cyclic data flows, generally `tag (current d) e` is preferred. Attach the current value of the d to the value of the  each time it occurs.BNote: `attachDyn d` is not the same as `attach (current d)`. See  for details.!Combine the current value of the d with the value of the  each time it occurs.NNote: `attachDynWith f d` is not the same as `attachWith f (current d)`. See  for details. Create a new I by combining the value at each occurence with the current value of the dA value and possibly filtering if the combining function returns .XNote: `attachDynWithMaybe f d` is not the same as `attachWithMaybe f (current d)`. See  for details. Demultiplex an input value to a cS with many outputs. At any given time, whichever output is indicated by the given d will be ."Select a particular output of the cJ; this is equivalent to (but much faster than) mapping over the original d3 and checking whether it is equal to the given key.O`abcdefghijklmnopqrstuvwxyz{|}~(`abcdefghijklmnopqrstuvwxyz{|}~(dijklmuvwnopqrst{yz|}~xcefg`abh<`abcdefghijklmnopqrstuvwxyz{|}~gNone !"=GKLNThis 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.vQuote a Dynamic 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 aNone!"34579;=>?CDILN GPropagate 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.iThis function is typically used in the main loop of a reflex framework implementation. The main loop waits for external events to happen (such as keyboard input or a mouse click) and then fires the corresponding events using this function. The read callback can be used to read output events and perform a corresponding response action to the external event.&Run a frame without any events firing.2This function should be used when you want to use  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.`This function is commonly used to set up the basic event network when the application starts up.CA monad where new events feed from external sources can be created.Creates a root , (one that is not based on any other event).9When 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.)Monad that allows to read events' values.Read 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 act` in an action to read the current value of the event. In the latter case, the function returns Nothing.4This function is normally used in the calllback for .Monad in which Events can be  subscribed. This forces all underlying event sources to be initialized, so that the event will fire whenever it ought to. Events must be subscribed before they are read using readEvent.Subscribe to an event and set it up if needed. This function will create a new  from an $. 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.TFramework implementation support class for the reflex implementation represented by t.Like !, but without reading any events./Create a new event and store its trigger in an IORef while it's active.An event is only active between the set up (when it's first subscribed to) and the teardown phases (when noboby is subscribing the event anymore). This function returns an Event and an IORef&. As long as the event is active, the IORef will contain M the event trigger to trigger this event. When the event is not active, the IORef will contain t. This allows event sources to be more efficient, since they don't need to produce events when nobody is listening.((None!"357;=>?CDIKLNU*Propagate everything at the current height&Run an event action outside of a frame      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~jkl`abcdeWXYZ[\]^_mnopqrstuvwTUVQRSOPIJKLMNEFGHBCD>?@A9:;<=78456-./0123()*+, !"#$%&'     xyz{|}~fghi       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdejklmnopqrstuvwxyz{|}~fghiNoneNonee !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF`abcdefghijklmnopqrstuvwxyz{|}~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#$       !"##$%&'())*+,,-./0112345567789:;<=>??@ABCDEFGHIJKLMNOPQRS TUVWXYZ[\]^_`abc)*-.defghijklmnopqrstuvwxyz{|}~+,XRhirefle_DSbw9XFAEh88jTiR4u9kr9Data.Functor.Misc Reflex.ClassReflex.DynamicReflex.Dynamic.THReflex.Host.ClassReflex.Spider.Internal Reflex.SpiderReflexConst2WrapArg sequenceDmapcombineDMapsWithKeywrapDMap rewrapDMap unwrapDMapunwrapDMapMaybe mapToDMapmapWithFunctorToDMap dmapToMap$fGCompare*Const2 $fGEq*Const2$fGCompare*WrapArg $fGEq*WrapArg EitherTagLeftTagRightTag FunctorMaybe fmapMaybe EventSelectorselect MonadHoldhold MonadSamplesampleBehaviorEventPushMPullMneverconstantpushpullmergefanswitch coincidence pushAlwaysffor fforMaybeffilterzipListWithEventtagattach attachWithattachWithMaybeonceEheadEtailE headTailEsplitE traceEventtraceEventWith eitherToDSum dsumToEither dmapToThese appendEvents sequenceThese mergeWithleftmost mergeListmergeMapfanMapswitchPromptlygateswitcher $fAlignEvent $fMonoidEvent$fShowTag*EitherTagIdentity$fGShow*EitherTag$fGCompare*EitherTag$fGEq*EitherTag$fFunctorEvent$fFunctorMaybeEvent$fMonoidBehavior$fSemigroupBehavior$fMonadBehavior$fApplicativeBehavior$fFunctorBehavior$fMonadHoldtContT$fMonadSampletContT$fMonadHoldtRWST$fMonadSampletRWST$fMonadHoldtExceptT$fMonadSampletExceptT$fMonadHoldtStateT$fMonadSampletStateT$fMonadHoldtWriterT$fMonadSampletWriterT$fMonadHoldtReaderT$fMonadSampletReaderTFHListFHNilFHConsDemuxDynamicHListHNilHCons unsafeDynamiccurrentupdatedconstDynholdDynnubDynmapDynforDynmapDynMfoldDynfoldDynM foldDynMaybe foldDynMaybeMcounttoggleswitchPromptlyDynsplitDyn mconcatDyndistributeDMapOverDyn combineDynjoinDynjoinDynThroughMaptraceDyn traceDynWithtagDyn attachDyn attachDynWithattachDynWithMaybedemux getDemuxeddistributeFHListOverDyn collectDynqDynunqDynmkDynMonadReflexHost ReadPhasefireEventsAndRead runHostFrameMonadReflexCreateTriggernewEventWithTriggernewFanEventWithTriggerMonadReadEvent readEventMonadSubscribeEventsubscribeEvent ReflexHost EventTrigger EventHandle HostFrame fireEventsnewEventWithTriggerRef fireEventReffireEventRefAndRead$fMonadReflexHosttRWST$fMonadSubscribeEventtRWST$fMonadReflexCreateTriggertRWST$fMonadReflexHosttExceptT$fMonadSubscribeEventtExceptT"$fMonadReflexCreateTriggertExceptT$fMonadReflexHosttContT$fMonadSubscribeEventtContT $fMonadReflexCreateTriggertContT$fMonadReflexHosttStateT$fMonadSubscribeEventtStateT!$fMonadReflexCreateTriggertStateT$fMonadReflexHosttStateT0$fMonadSubscribeEventtStateT0"$fMonadReflexCreateTriggertStateT0$fMonadReflexHosttWriterT$fMonadSubscribeEventtWriterT"$fMonadReflexCreateTriggertWriterT$fMonadReflexHosttReaderT$fMonadSubscribeEventtReaderT"$fMonadReflexCreateTriggertReaderT runReadPhaseSpiderHostFramerunSpiderHostFrame SpiderHost runSpiderHostSpiderEventHandle unEventHandle RootTriggerSpiderSomeSwitchSubscribedSomeCoincidenceInfoWeakList DelayedMergeSomeAssignment SomeDMapIORefSomeMaybeIORefResultM BehaviorHold BehaviorConst BehaviorPullEventSubscribedEventSubscribedRootEventSubscribedNeverEventSubscribedPushEventSubscribedMergeEventSubscribedFanEventSubscribedSwitchEventSubscribedCoincidence EventRoot EventNever EventPush EventMergeEventFan EventSwitchEventCoincidence SubscriberSubscriberPushSubscriberMerge SubscriberFanSubscriberHoldSubscriberSwitchSubscriberCoincidenceOuterSubscriberCoincidenceInnerWeakSubscriberWeakSubscriberMergeWeakSubscriberSimpleBoxunBox CoincidencecoincidenceParentcoincidenceSubscribedCoincidenceSubscribedcoincidenceSubscribedOccurrence coincidenceSubscribedSubscriberscoincidenceSubscribedHeightcoincidenceSubscribedOuter coincidenceSubscribedOuterParent coincidenceSubscribedInnerParentSwitch switchParentswitchSubscribedSwitchSubscribedswitchSubscribedOccurrenceswitchSubscribedHeightswitchSubscribedSubscribersswitchSubscribedSelfswitchSubscribedSelfWeakswitchSubscribedOwnInvalidator"switchSubscribedOwnWeakInvalidatorswitchSubscribedBehaviorParentsswitchSubscribedParentswitchSubscribedCurrentParentFan fanParent fanSubscribed FanSubscribedfanSubscribedSubscribersfanSubscribedParentfanSubscribedSelfFanSubscriberKeyMerge mergeParentsmergeSubscribedMergeSubscribedmergeSubscribedOccurrencemergeSubscribedAccummergeSubscribedHeightmergeSubscribedSubscribersmergeSubscribedSelfmergeSubscribedParentsPush pushCompute pushParentpushSubscribedPushSubscribedpushSubscribedOccurrencepushSubscribedHeightpushSubscribedSubscriberspushSubscribedSelfpushSubscribedParentEventMunEventM SomeHoldInitRootrootOccurrencerootSubscribedrootInitRootSubscribedrootSubscribedSubscribersrootSubscribedOccurrence InvalidatorInvalidatorPullInvalidatorSwitchPull pullValue pullComputePullSubscribedpullSubscribedValuepullSubscribedInvalidatorspullSubscribedOwnInvalidatorpullSubscribedParentsSomeBehaviorSubscribedBehaviorSubscribedBehaviorSubscribedHoldBehaviorSubscribedPull BehaviorM unBehaviorMEventEnveventEnvAssignmentseventEnvHoldInitseventEnvClearseventEnvRootClearseventEnvCurrentHeighteventEnvCoincidenceInfoseventEnvDelayedMergesHold holdValueholdInvalidatorsholdSubscriber holdParentSpiderBehaviorunSpiderBehavior SpiderEvent unSpiderEventdebugPropagatedebugInvalidateHeight showNodeId runEventMaskToAssignRefaskHoldInitRefgetCurrentHeightputCurrentHeight scheduleClearscheduleRootClear scheduleMergeemitCoincidenceInfo subscribeHoldshowWeakSubscriberTypedeRefWeakSubscribershowSubscriberType showEventTypenewRootSubscribednewSubscriberPushnewSubscriberHoldnewSubscriberFannewSubscriberSwitchnewSubscriberCoincidenceOuternewSubscriberCoincidenceInnernewInvalidatorSwitchnewInvalidatorPullnewBoxunsafeNewIORefnewRoot propagateAndUpdateSubscribersRefrun debugFinalizemkWeakPtrWithDebugtraverseAndCleanWeakList_ propagatesubscribeCoincidenceInner readBehavior runBehaviorMaskInvalidator askParentsRefreadBehaviorTrackedzeroRefgetEventSubscribeddebugSubscribesubscribeEventSubscribedgetEventSubscribedOcceventSubscribedHeightRef subscribe noinlineFalsegetRootSubscribedgetPushSubscribedgetMergeSubscribedgetFanSubscribedgetSwitchSubscribedgetCoincidenceSubscribedrunFrame invalidHeightinvalidateSubscriberHeightinvalidateCoincidenceHeightrecalculateSubscriberHeightrecalculateCoincidenceHeightcalculateMergeHeightcalculateSwitchHeightcalculateCoincidenceHeightdebugInvalidate invalidatenewEventWithTriggerIOnewFanEventWithTriggerIO$fMonadAtomicRefSpiderHostFrame$fMonadRefSpiderHostFrame$fMonadAtomicRefSpiderHost$fMonadRefSpiderHost!$fMonadReflexHostSpiderSpiderHost%$fMonadSubscribeEventSpiderSpiderHost/$fMonadReflexCreateTriggerSpiderSpiderHostFrame*$fMonadReflexCreateTriggerSpiderSpiderHost $fMonadHoldSpiderSpiderHostFrame"$fMonadSampleSpiderSpiderHostFrame$fMonadAtomicRefEventM$fMonadRefEventM$fMonadReadEventSpiderReadPhase$fReflexHostSpider*$fMonadSubscribeEventSpiderSpiderHostFrame$fMonadHoldSpiderEventM$fMonadSampleSpiderEventM$fMonadSampleSpiderBehaviorM$fMonadHoldSpiderSpiderHost$fMonadSampleSpiderSpiderHostTFCo:R:BehaviorSpideraTFCo:R:EventSpidera$fReflexSpider$fGCompare*FanSubscriberKey$fGEq*FanSubscriberKeybase Data.EitherEitherdepen_9jCsPjr2EGgG8iN7Qj6YGVData.Dependent.SumDSumGHC.BaseMaybefmapStringdepen_2QMCTv0o4y6FUA7rTj3D0XData.Dependent.Map.InternalDMapmappendFunctorMonoidconta_2C3ZI8RgPO2LBMidXKTvIU Data.Map.BaseMapNothingghc-prim GHC.TypesTrueIsHList HListElemstoHList fromHListAllAreFunctors FunctorListtoFHList fromFHListRebuildSortedHListrebuildSortedFHListrebuildSortedHListHListPtrHHeadPtrHTailPtr demuxValue demuxSelectorHBuild'hBuild'HRevApphRevApphReversehBuild fhlistToDMap dmapToHList$fIsHList(,,,,,)$fIsHList(,,,) $fIsHList(,)$fAllAreFunctorskf:$fAllAreFunctorskf[]$fRebuildSortedHList:$fRebuildSortedHList[]$fGComparekHListPtr$fGEqkHListPtr$fHBuild'l(->)$fHBuild'lHListTFCo:R:HRevAppk:l'TFCo:R:HRevAppk[]lUnqDyn unqMarkermkDynExpJust