>      !"#$%&'()*+,-./0123456789:;<=None!"&*34579>CDFILN XData type for an initial value which is updated, mainly useful for it's Functor instanceLData type for a collection (a map) which is updated by providing differences9Generalized unzip - probably not the best place for this!RTurn an UpdatedMap into a Dynamic by applying the differences to the initial valueMHold an UpdatedMap as a behavior by applying differences to the initial valueHold an 9 as a Dynamic by replacing the initial value with updatesHold an : as a Behavior by replacing the initial value with updates BFind the shallow (structural) differences between two Maps OTrack the shallow (structural) differences between a Behavior and an Event  >?@    >?@None!"&*34579>CDFILN 6Switching for a changing collections of reactive typesBGeneralization of switchable reactive types (e.g. Event, Behavior)dHelper which takes an UpdatedMap as one argument (instead of initial value, update event separately)aHelper which takes an Updated as one argument (instead of initial value, update event separately) ABCDEFGHIJKL     ABCDEFGHIJKLNone!"&*34579>CDFILNMap the result of an initial monadic action and updates and swap it out with a new one whenever the event provided fires. returns an Updated giving the initial value plus updatesJSimilar to holdM but operating on a collection of widgets provided as an q. switchM/switchM' can be implemented in terms of switchMapM therefore switchMapM is a minimal implementation.0Constraint type to capture common usage together MNOPQR~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ MNOPQRNone!"&*34579>CDFILN}Base Monad which sits at the bottom of a (pure) switching Monad transformer stack providing the base switching capabilities.  None!"&*34579>CDFILNNon transformer version ID Supply transformer for switchable reflex stacks over splittable ID supplies Fresh variables are obtained using getFresh. Admits a MonadSwitch instance. !Abstraction for splittable identifier supplies, priovided is an instance for Enum a => [a] but a more efficient supply would be for example, found in the concurrent-supply package. at the cost of determinism. Two parameters, a state s and an identifier type i$!Obtain a fresh ID from the Supply%kObtain a value of the ID Supply which provides distinct ids from those returned from the Monad in future.&+Run a non transformer Supply using a split '$Run a SupplyT with a Spittable state%Helpers for switchMapM implementation !"#$%&'()*  !"#$%&'()* !"#'()*&$% !"#$%&'()*None!"&*34579>CDFILN,gFusion between ReaderT and WriterT (But not StateT unlike RWST) which is switchable using MonadSwitchUses implementation based on RSST which implements WriterT using state in order to avoid space leaks incurred by the original WriterT +,-./+,-./,+-/. +,-./None!"&*34579>CDFILN 0FData type wrapping chainable widgets of the type (a -> m (Event t a)) 3!Recursive Workflow datatype, see : below6Hold a monadic widget and update it whenever the Event provides a new monadic widget, swapping out the previously active widget. Returns a Dynamic giving the return values of widgets created7Non monadic version of collection, builds a collection from an initial list and a list of updated values items remove themselves upon the event triggering. returns an UpdatedMap with keys assigned to items in ascending order8Builds a collection of widgets from an initial list and events providing new widgets to create as with collect, items remove themselves upon the event triggering. returns an UpdatedMap with keys assigned to items in ascending order9Provides a view into a Dynamic Map value, where sub-views are created using a function passed in returns a Dynamic Map of values returned from child views upon creation.:Provide a widget which swaps itself out for another widget upon an event (recursively) Useful if the sequence of widgets needs to return a value (as opposed to passing it down the chain).;Provide a way of chaining widgets of type (a -> m (Event t b)) where one widgets swaps out the old widget. De-couples the return type as compared to using :<vProvide a way of looping (a -> m (Event t a)), each iteration switches out the previous iteration. Can be used with = Compose two 0U values passing the output event of one into the construction function of the next.0123456789:;<=STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 0123456789:;<=6987345:012;=< 0123456789:;<=2=        !"#$%&'()*+,-./012345567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXVWYVWZVW[VW\VW]VW^_`a_`b_`c_`c_de_df_gh_gi_gj_gk_gl_gm_gn_go_gp_gq_gr_gs_gt_gu_gv_gw_gx_gy_gz_g{_g|_g}_g~_g_g_g_g_g_g_g_g_g_g_g_g_g_g_g______________________________________________________%1refle_LeKGb2n6q8H7oNT0jmwiptReflex.UpdatedReflex.SwitchingReflex.Monad.ClassReflex.Monad.ReflexMReflex.Monad.SupplyReflex.Monad.ReaderWriter Reflex.MonadUpdated UpdatedMapsplit holdMapDynholdMapholdDyn'hold' shallowDiff' shallowDiff SwitchMerge switchMerge Switching switching switchMerge' switching' MonadSwitchswitchM switchMapM MonadReflexReflexM runReflexM$fMonadSwitchtReflexM$fMonadHoldtReflexM$fMonadSampletReflexM$fMonadFixReflexM$fMonadReflexM$fApplicativeReflexM$fFunctorReflexMSupplySupplyT SplitablefreshId splitSupplygetFreshgetSplitrunSplit runSupplyT evalSupplyT runSupply evalSupply ReaderWriter ReaderWriterTrunReaderWriterTexecReaderWriterTrunReaderWriterChain:>>WorkflowunFlow widgetHoldcollect collectionmapViewworkflowchainloop>->$fFunctorWithIndexkUpdatedMap$fFunctorUpdated$fFunctorUpdatedMapswitchMergeEvents mayConcat$fSwitchingt()$fSwitchingtEvent$fSwitchingtBehavior$fSwitchMerget()$fSwitchingt[]$fSwitchMerget[]$fSwitchMergetBehavior$fSwitchMergetEvent$fSwitchMerget(,)$fSwitchingt(,) maybeToMap mapToMaybetoMapfromMap$fMonadSwitchtWriterT$fMonadSwitchtReaderTmtl_KMpng31YRYc5JfMWFZ3FCUControl.Monad.Writer.Classlistencensor MonadWriterpasslistenstellwriterrefle_2UrSqcOA3BADztf7ETBYqAReflex.Spider.InternalSpider runSpiderHost SpiderHostReflex.Dynamic.THunqDynqDynReflex.Dynamic collectDyndistributeFHListOverDyn getDemuxeddemuxattachDynWithMaybe attachDynWith attachDyntagDyn traceDynWithtraceDynjoinDynThroughMapjoinDyn combineDyndistributeDMapOverDyn mconcatDynsplitDynswitchPromptlyDyntogglecountfoldDynMfoldDynmapDynMforDynmapDynnubDynholdDynconstDynupdatedcurrent unsafeDynamicHConsHNilHListDynamicDemuxFHConsFHNilFHList Reflex.ClassswitchergateswitchPromptlyfanMapmergeMap mergeListleftmost mergeWith sequenceThese appendEvents dmapToThese dsumToEither eitherToDSumtraceEventWith traceEventsplitE headTailEtailEheadEonceEattachWithMaybe attachWithattachtagzipListWithEventffilter fforMaybeffor pushAlways coincidenceswitchfanmergepullpushconstantneverPullMPushMEventBehaviorReflexsample MonadSamplehold MonadHoldselect EventSelector fmapMaybe FunctorMaybeRightTagLeftTag EitherTag runSupplyMap runSupplyMap'$fMonadSwitchtSupplyT$fMonadStatestSupplyT$fSplitable[][]$fMonadSwitchtReaderWriterT$fMonadStatesReaderWriterT$fMonadHoldtReaderWriterT$fMonadSampletReaderWriterTwithIdstoFlow