!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred!"+=HM      None!"*+23468<=BCHJKLMT, Tag type for  to use it as a .=A class for values that combines filtering and mapping using .(Combined mapping and filtering function.Create a new Behavior whose value will initially be equal to the given value and will be updated whenever the given Event occurs%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./ Create a new & that combines occurences of supplied  with the current value of the .0 Create a new  that occurs when the supplied 7 occurs by combining it with the current value of the .1 Create a new < by combining each occurence with the current value of the H. The occurrence is discarded if the combining function returns Nothing2 Alias for 33 Create a new : that only occurs on the first occurence of the supplied .4 Create a new = that occurs on all but the first occurence of the supplied .5Create 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.6Split the supplied  into two individual Gs occuring at the same time with the respective values from the tuple.7Print 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.8DPrint 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.9Convert  to a  . Inverse of :.:Convert  to  . Inverse of 9.;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.@ 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.A 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.BSplit the event into an 4 that allows efficient selection of the individual s.CSwitches to the new event whenever it receives one; the new event is used immediately, on the same frame that it is switched toD Create a new " that only occurs if the supplied  occurs and the " is true at the time of occurence.@ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO5 !"#$%&'()*+,-./0123456789:;<=>?@ABCD@!"#$ %&'(ON)*M+,LK-./012345678JIHG9:;<=F>?@ABCED- !"#$ %&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNONone!"'(*+23468<=BCHJKLMTS2Represents 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.TuA 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.Y Extract the  of a T.Z Extract the  of the T.[T" with the constant supplied value.\ Create a T6 using the initial value that changes every time the  occurs.] Create a new T; that only signals changes if the values actually changed.^Map a function over a T._Flipped version of ^.`Map a monadic function over a TC. The only monadic action that the given function can perform is .a Create a T6 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 .b Create a T6 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 .c Create a new T# that counts the occurences of the .d Create a new T> using the initial value that flips its value every time the  occurs.eSwitches to the new A whenever it receives one. Switching occurs *before* the inner  fires - so if the Tv changes and both the old and new inner Events fire simultaneously, the output will fire with the value of the *new* .f Split the T into two T2s, each taking the respective value of the tuple.g Merge the T values using their  instance.h Create a T with a  of values out of a  of Dynamic values.i Merge two T7s into a new one using the provided function. The new T2 changes its value each time one of the original Ts changes its value.jJoin a nested T into a new T" that has the value of the inner T.k Combine a T of a  of T s into a T! with the current values of the T s in a map.lPrint the value of the TE 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.mHPrint the result of applying the provided function to the value of the T 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.nReplace the value of the  with the current value of the T 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 T, because that would mean its value depends on itself. When creating cyclic data flows, generally `tag (current d) e` is preferred.o Attach the current value of the T to the value of the  each time it occurs.BNote: `attachDyn d` is not the same as `attach (current d)`. See n for details.p!Combine the current value of the T with the value of the  each time it occurs.NNote: `attachDynWith f d` is not the same as `attachWith f (current d)`. See n for details.q Create a new I by combining the value at each occurence with the current value of the TA value and possibly filtering if the combining function returns .XNote: `attachDynWithMaybe f d` is not the same as `attachWithMaybe f (current d)`. See n for details.r Demultiplex an input value to a SS with many outputs. At any given time, whichever output is indicated by the given T will be .s"Select a particular output of the SJ; this is equivalent to (but much faster than) mapping over the original T3 and checking whether it is equal to the given key.MPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu&PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu&TYZ[\]cdenopq^_`abiughjklmfSrsUWVPRQtX:PRQSTUWVXYZ[\]^_`abcdefghijklmnopqrstuVNone !"<FJKMThis 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.vvQuote 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 avwvwvwvwNone!"2468:<=>BCHKM~Creates an original Event (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 by passing a trigger. The event is then set up in IO. The callback function returns an accompanying teardown action. Any time between setup and teardown the trigger can be used to fire the event.xyz{|}~xyz{|}~}~xyz{|xyz{|}~None!"246:<=>BCHKMT]*Propagate everything at the current heightu&Run an event action outside of a frame      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~789-./012%&'()*+,:;<=>?@ABC"#$!      DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3456      ! "#$%&'()*+,-./012789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3456NoneNonea !"#$%&'()*+,-./0123456789:;<=>?@ABCDPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"#       !"#$%&'()*+,-./0123(),-456789:;<=>?@ABCDEFGHIJKLMN*+OPQRSTUVWXYZ[\]^_`abcdefghijklmnRPopqrstuvqwxqyzqy{|}~qqqwXY reflex-0.2Data.Functor.Misc Reflex.ClassReflex.DynamicReflex.Dynamic.THReflex.Host.ClassReflex.Spider.Internal Reflex.SpiderReflexConst2WrapArg sequenceDmapcombineDMapsWithKeywrapDMap rewrapDMap unwrapDMap mapToDMapmapWithFunctorToDMap dmapToMap$fGCompare*Const2 $fGEq*Const2$fGCompare*WrapArg $fGEq*WrapArg EitherTagRightTagLeftTag FunctorMaybe fmapMaybe EventSelectorselect MonadHoldhold MonadSamplesampleBehaviorEventPushMPullMneverconstantpushpullmergefanswitch coincidence pushAlwaysffor fforMaybeffilterzipListWithEventtagattach attachWithattachWithMaybeonceEheadEtailE headTailEsplitE traceEventtraceEventWith eitherToDSum dsumToEither dmapToThese appendEvents sequenceThese mergeWithleftmost mergeListmergeMapfanMapswitchPromptlygate $fAlignEvent $fMonoidEvent$fShowTagEitherTag$fGShowEitherTag$fGCompare*EitherTag$fGEq*EitherTag$fFunctorEvent$fFunctorMaybeEvent$fFunctorBehavior$fMonadHoldtReaderT$fMonadSampletReaderTFHListFHConsFHNilDemuxDynamicHListHConsHNil unsafeDynamiccurrentupdatedconstDynholdDynnubDynmapDynforDynmapDynMfoldDynfoldDynMcounttoggleswitchPromptlyDynsplitDyn mconcatDyndistributeDMapOverDyn combineDynjoinDynjoinDynThroughMaptraceDyn traceDynWithtagDyn attachDyn attachDynWithattachDynWithMaybedemux getDemuxeddistributeFHListOverDyn collectDynqDynunqDynMonadReflexHostfireEventsAndReadsubscribeEventrunFrame runHostFrameMonadReflexCreateTriggernewEventWithTriggerMonadReadEvent readEvent ReflexHost EventTrigger EventHandle HostFrame fireEventsnewEventWithTriggerRef$fMonadReflexHosttReaderT"$fMonadReflexCreateTriggertReaderTSpiderHostFramerunSpiderHostFrame SpiderHost runSpiderHost RootTriggerSpiderSomeSwitchSubscribedSomeCoincidenceInfoWeakList DelayedMergeSomeAssignmentSomeMaybeIORefResultM BehaviorPull BehaviorConst BehaviorHoldEventSubscribedEventSubscribedCoincidenceEventSubscribedSwitchEventSubscribedFanEventSubscribedMergeEventSubscribedPushEventSubscribedNeverEventSubscribedRootEventCoincidence EventSwitchEventFan EventMerge EventPush EventNever EventRoot SubscriberSubscriberCoincidenceInnerSubscriberCoincidenceOuterSubscriberSwitchSubscriberHold SubscriberFanSubscriberMergeSubscriberPushWeakSubscriberWeakSubscriberSimpleWeakSubscriberMergeBoxunBox CoincidencecoincidenceParentcoincidenceSubscribedCoincidenceSubscribedcoincidenceSubscribedOccurrence coincidenceSubscribedSubscriberscoincidenceSubscribedHeightcoincidenceSubscribedOuter coincidenceSubscribedOuterParent coincidenceSubscribedInnerParentSwitch switchParentswitchSubscribedSwitchSubscribedswitchSubscribedOccurrenceswitchSubscribedHeightswitchSubscribedSubscribersswitchSubscribedSelfswitchSubscribedSelfWeakswitchSubscribedOwnInvalidator"switchSubscribedOwnWeakInvalidatorswitchSubscribedBehaviorParentsswitchSubscribedParentswitchSubscribedCurrentParentFan fanParent fanSubscribed FanSubscribedfanSubscribedSubscribersfanSubscribedParentfanSubscribedSelfFanSubscriberKeyMerge mergeParentsmergeSubscribedMergeSubscribedmergeSubscribedOccurrencemergeSubscribedAccummergeSubscribedHeightmergeSubscribedSubscribersmergeSubscribedSelfmergeSubscribedParentsPush pushCompute pushParentpushSubscribedPushSubscribedpushSubscribedOccurrencepushSubscribedHeightpushSubscribedSubscriberspushSubscribedSelfpushSubscribedParentEventMunEventM SomeHoldInitRootrootOccurrencerootSubscribedrootInitRootSubscribedrootSubscribedSubscribersrootSubscribedOccurrence InvalidatorInvalidatorSwitchInvalidatorPullPull pullValue pullComputePullSubscribedpullSubscribedValuepullSubscribedInvalidatorspullSubscribedOwnInvalidatorpullSubscribedParentsSomeBehaviorSubscribedBehaviorSubscribedBehaviorSubscribedPullBehaviorSubscribedHold BehaviorM unBehaviorMEventEnveventEnvAssignmentseventEnvHoldInitseventEnvClearseventEnvCurrentHeighteventEnvCoincidenceInfoseventEnvDelayedMergesHold holdValueholdInvalidatorsholdSubscriber holdParentSpiderBehaviorunSpiderBehavior SpiderEvent unSpiderEventdebugPropagatedebugInvalidateHeight showNodeId runEventMaskToAssignRefaskHoldInitRefgetCurrentHeightputCurrentHeight scheduleClear scheduleMergeemitCoincidenceInfo subscribeHoldshowWeakSubscriberTypedeRefWeakSubscribershowSubscriberType showEventTypenewRootSubscribednewSubscriberPushnewSubscriberHoldnewSubscriberFannewSubscriberSwitchnewSubscriberCoincidenceOuternewSubscriberCoincidenceInnernewInvalidatorSwitchnewInvalidatorPullnewBoxunsafeNewIORefnewRoot propagateAndUpdateSubscribersRefrun debugFinalizemkWeakPtrWithDebugtraverseAndCleanWeakList_ propagatesubscribeCoincidenceInner readBehavior runBehaviorMaskInvalidator askParentsRefreadBehaviorTrackedzeroRefgetEventSubscribeddebugSubscribesubscribeEventSubscribedgetEventSubscribedOcceventSubscribedHeightRef subscribe noinlineFalsegetRootSubscribedgetPushSubscribedgetMergeSubscribedgetFanSubscribedgetSwitchSubscribedgetCoincidenceSubscribed invalidHeightinvalidateSubscriberHeightinvalidateCoincidenceHeightrecalculateSubscriberHeightrecalculateCoincidenceHeightcalculateMergeHeightcalculateSwitchHeightcalculateCoincidenceHeightdebugInvalidate invalidatenewEventWithTriggerIO$fMonadAtomicRefSpiderHostFrame$fMonadRefSpiderHostFrame$fMonadAtomicRefSpiderHost$fMonadRefSpiderHost!$fMonadReflexHostSpiderSpiderHost/$fMonadReflexCreateTriggerSpiderSpiderHostFrame*$fMonadReflexCreateTriggerSpiderSpiderHost $fMonadHoldSpiderSpiderHostFrame"$fMonadSampleSpiderSpiderHostFrame$fMonadAtomicRefEventM$fMonadRefEventM$fMonadReadEventSpiderEventM$fReflexHostSpider$fMonadHoldSpiderEventM$fMonadSampleSpiderEventM$fMonadSampleSpiderBehaviorM$fMonadHoldSpiderSpiderHost$fMonadSampleSpiderSpiderHostTFCo:R:BehaviorSpideraTFCo:R:EventSpidera$fReflexSpider$fGCompare*FanSubscriberKey$fGEq*FanSubscriberKeybase Data.EitherEitherdependent-sum-0.2.1.0Data.Dependent.SumDSum Data.MaybeMaybeGHC.BasefmapStringdependent-map-0.1.1.3Data.Dependent.Map.InternalDMap Data.MonoidmappendMonoidcontainers-0.5.5.1 Data.Map.BaseMapNothingghc-prim GHC.TypesTrueIsHList HListElemstoHList fromHListAllAreFunctors FunctorListtoFHList fromFHListRebuildSortedHListrebuildSortedFHListrebuildSortedHListHListPtrHTailPtrHHeadPtr 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 unqMarker