h*]V?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 0.1 Safe-Inferred)*\  WidgetRattus,The "stable" type modality. A value of type Box a is a time-independent computation that produces a value of type a. Use $ and % to construct and consume  -types. WidgetRattus A type is Stable0 if it is a strict type and the later modality O% and function types only occur under Box.%For example, these types are stable: Int,  Box (a -> b),  Box (O Int), Box (Sig a -> Sig b). But these types are not stable: [Int]) (because the list type is not strict),  Int -> Int!, (function type is not stable), O Int, Sig Int. WidgetRattusThe return type of the ! primitive. WidgetRattus#The "later" type modality. A value v of type O 1 consists of two components: Its clock, denoted cl(v)?, and a delayed computation that will produce a value of type  as soon as the clock cl(v) ticks. The clock cl(v) is only used for type checking and is not directly accessible, whereas the delayed computation is accessible via   and !. WidgetRattus1This is the constructor for the "later" modality : :  N E t ::  --------------------  E delay t :: O +The typing rule requires that its argument t$ typecheck with an additional tick N of some clock .  WidgetRattus0This is the eliminator for the "later" modality :   E t :: O  ' tick-free ---------------------------------  Ncl(t) ' E adv t :: It requires that a tick N= is in the context whose clock matches exactly the clock of t, i.e.   = cl(t).! WidgetRattusIf we want to eliminate more than one delayed computation, i.e. two s :: O  and t :: O , we need to use ! instead of just  .   E s :: O   E t :: O  ' tick-free --------------------------------------------------  Ncl(s)Ecl(t) ' E select s t :: Select   It requires that we have a tick N in the context whose clock matches the union of the clocks of s and t, i.e.  = cl(s)Ecl(t). The union of two clocks ticks whenever either of the two clocks ticks, i.e.  cl(s)Ecl(t) , whenever cl(s) or cl(t) ticks.That means there are three possible outcomes, which are reflected in the result type of  select s t . A value of  Select   is eithera value of type # and a delayed computation of type O  , if cl(s) ticks before cl(t),a value of type # and a delayed computation of type O  , if cl(t) ticks before cl(s), ora value of type  and a value of type , if cl(s) andcl(s) tick simultaneously.# WidgetRattus The clock of  never :: O > will never tick, i.e. it will never produce a value of type . With #3 we can for example implement the constant signal  x ::: never of type Sig a for any x :: a.$ WidgetRattus2This is the constructor for the "stable" modality  : 8 L E t ::  --------------------  E box t :: Box where L is obtained from  by removing all ticks and all variables x :: , where  is not a stable type.% WidgetRattus2This is the eliminator for the "stable" modality  : 5  E t :: Box  ------------------  E unbox t :: ) WidgetRattusAtomic version of *.* WidgetRattusFor promote to work, its argument must be stored in the "promote store", and whenenver an input is received on some channel, all values in the "promote store" must be advanced (using  ).'  !"#$%&'()*+' !"# $%& '()*+  Safe-Inferred WidgetRattusThis function provides a list (of the given length) of new names based on the given string. WidgetRattus This is the Q$-lifted version of 'abstractNewtype. WidgetRattusApply a class name to type arguments to construct a type class constraint. WidgetRattusThis function provides the name and the arity of the given data constructor, and if it is a GADT also its type. WidgetRattus-Same as normalCon' but expands type synonyms. WidgetRattus7This function returns the name of a bound type variable WidgetRattusThis function abstracts away newtype# declaration, it turns them into data declarations.- Safe-Inferred7. WidgetRattus.This annotation type is for internal use only.1 WidgetRattusBy default all Async Rattus functions are checked for use of lazy data types, since these may cause memory leaks. If any lazy data types are used, a warning is issued. These warnings can be disabled by annotating the module or the function with 2 {-# ANN myFunction AllowLazyData #-} {-# ANN module AllowLazyData #-}Async Rattus only allows guarded recursion, i.e. recursive calls must occur in the scope of a tick. Structural recursion over strict data types is safe as well, but is currently not checked. To disable the guarded recursion check, annotate the module or function with 3. {-# ANN myFunction AllowRecursion #-} {-# ANN module AllowRecursion #-}123./0123./0  Safe-Inferred)* WidgetRattus"Syntax that may contain variables. WidgetRattusCompute the set of variables occurring in the given piece of syntax. The name falsely suggests that returns free variables, but in fact it returns all variable occurrences, no matter whether they are free or bound. WidgetRattusComputes the variables that are bound by a given piece of syntax. WidgetRattusCompute the dependencies of a bag of bindings, returning a list of the strongly-connected components.  Safe-Inferred"9 WidgetRattus!The set of stable built-in types. WidgetRattus t4, this function returns the list of type variables  [a1,...,am]" for which there is a constraint  Stable ai among  C1, ... Cn. WidgetRattusChecks a top-level definition group, which is either a single non-recursive definition or a group of (mutual) recursive definitions. WidgetRattusStabilizes the given context, i.e. remove all non-stable types and any tick. This is performed on checking box, and guarded recursive definitions. To provide better error messages a reason has to be given as well. WidgetRattusKML^_BCDE?@ANOPRQSTUV=>KML^_BCDE=2>2A8 Safe-Inferred)*?f WidgetRattusA type p satisfying  Producer p a7 is essentially a signal that produces values of type a4 but it might not produce such values at each tick.g WidgetRattus-Get the current value of the producer if any.h WidgetRattusGet the next state of the producer. Morally, the type of this method should be /getNext :: p -> (exists q. Producer q a => O q)We encode the existential type using continuation-passing style.l WidgetRattusThis function can be used to implement input signals. It returns a boxed delayed computation s and a callback function cb. The signal mkSig s will produce a new value v! whenever the callback function cb is called with argument v.m WidgetRattus>This function can be used to produces outputs. Given a signal s and function f , the call  setOutput s f registers f6 as a callback function that is called with argument v+ whenever the signal produces a new value v. For this function to work, p must be called.n WidgetRattus0This function is essentially the composition of l and m&. It turns any producer into a signal.o WidgetRattustimer n1 produces a delayed computation that ticks every n milliseconds. In particular mkSig (timer n). is a signal that produces a new value every n milliseconds.p WidgetRattus In order for m) to work, this IO action must be invoked.lmnpofghicdejklmnpofghicdejk Safe-Inferred?I1  !% +$#?@A=>KMLRNUVOPQST^_BCDE-123v-123v Safe-Inferred Sw WidgetRattusSig a is a stream of values of type a.y WidgetRattus"Get the current value of a signal.z WidgetRattusGet the future the signal.{ WidgetRattus*Apply a function to the value of a signal.| WidgetRattus Variant of l? that returns a signal instead of a boxed delayed computation.} WidgetRattus4Turn a producer into a signal. This is a variant of n? that returns a signal instead of a boxed delayed computation.~ WidgetRattus0This function is essentially the composition of  with {. The signal produced by  filterMap f s has the value v whenever s has the value u such that unbox f u = Just' v. WidgetRattusThis function is similar to ~# but takes a delayed signal (type  O (Sig a)&) as an argument instead of a signal (Sig a). WidgetRattusFilter the given signal using a predicate. The signal produced by  filter p s contains only values from s that satisfy the predicate p. WidgetRattusThis function is similar to # but takes a delayed signal (type  O (Sig a)&) as an argument instead of a signal (Sig a). WidgetRattusThis function is a variant of  . Whereas zipWith f xs ys produces a new value whenever xs or ys produce a new value, trigger f xs ys9 only produces a new value when xs produces a new value.Example:  xs: 1 2 3 2 ys: 1 0 5 2 zipWith (box (+)) xs ys: 2 3 4 3 8 4 trigger (box (+)) xy ys: 2 3 8 4 WidgetRattusThis function is similar to # but takes a delayed signal (type  O (Sig a)&) as an argument instead of a signal (Sig a). WidgetRattus A version of map for delayed signals. WidgetRattus8Turns a boxed delayed computation into a delayed signal. WidgetRattus Variant of $ that returns a boxed delayed signal WidgetRattus/Construct a constant signal that never updates. WidgetRattusSimilar to Haskell's . scan (box f) x (v1 ::: v2 ::: v3 ::: ... ) == (x `f` v1) ::: ((x `f` v1) `f` v2) ::: ... Note: Unlike ,  starts with x f v1, not x. WidgetRattusLike , but uses a delayed signal. WidgetRattus is a composition of { and : "scanMap f g x === map g . scan f x WidgetRattusThis function allows to switch from one signal to another one dynamically. The signal defined by  switch xs ys first behaves like xs, but as soon as ys produces a new value,  switch xs ys behaves like ys.Example:  xs: 1 2 3 4 5 6 7 8 9 ys: 1 2 3 4 5 6 switch xs ys: 1 2 3 1 2 4 3 4 5 6 WidgetRattusThis function is similar to , but the (future) second signal may depend on the last value of the first signal. WidgetRattusThis function is similar to 2 but works on delayed signals instead of signals. WidgetRattus? @ABCDEFGHIJKLMNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsttuvwxyz{|}~                                               (#!('WidgetRattus-0.1-CrXVeD6uiRKF12UdxmgEWpAsyncRattus.StrictAsyncRattus.InternalPrimitives AsyncRattusAsyncRattus.Plugin.AnnotationAsyncRattus.PluginAsyncRattus.ChannelsAsyncRattus.SignalAsyncRattus.Future WidgetRattusAsyncRattus.DeriveAsyncRattus.Plugin.DependencyAsyncRattus.Plugin.UtilsAsyncRattus.Plugin.StrictifyAsyncRattus.Plugin.StableSolverAsyncRattus.Plugin.SingleTickAsyncRattus.Plugin.ScopeCheckAsyncRattus.Plugin.PrimExprAsyncRattus.Plugin.Transform*AsyncRattus.Plugin.CheckClockCompatibilityAsyncRattus.Primitivesbase GHC.IsListIsListfromList fromListNtoListItemChanContinuousData ContinuousprogressInternalpromoteInternalBoxStableSelectFstSndBothODelay InputValueClockInputChannelIdentifiersingletonClock clockUnion channelMemberasyncRattusErrordelay extractClockadv'advselectselect'neverboxunboxdefaultPromote promoteStoreprogressPromoteStoreMutexprogressPromoteStoreAtomicprogressPromoteStorepromote $fContinuousa continuous InternalAnn ExpectError ExpectWarning AllowLazyDataAllowRecursion$fDataInternalAnn$fShowInternalAnn$fEqInternalAnn$fOrdInternalAnn$fDataAsyncRattus$fShowAsyncRattus$fOrdAsyncRattus$fEqAsyncRattusplugin:*ListNil:!fst'snd'curry'uncurry'$fVectorSpace:*a$fEq:*$fShow:* $fFunctor:*$fContinuous:*Maybe'Just'Nothing' singletoninit'reverse' listToMaybe'+++map'zip'zipWith' mapMaybe' $fShowList$fEqList $fFunctorList$fFoldableList $fIsListList$fTraversableList$fContinuousListmaybe' fromMaybe' $fShowMaybe' $fEqMaybe'$fContinuousMaybe'CunCProducer getCurrentgetNextchandelayCwaitgetInput setOutputmkInputtimerstartEventLoop$fProducerBoxa $fProducerOa $fFunctorC$fApplicativeC$fMonadCmapOSig:::currentfuturemap getInputSig mkInputSig filterMapfilterMapAwaitfilter filterAwaittrigger triggerAwaitmapAwaitmkSigmkBoxSigconstscanscanC scanAwait scanAwaitCscanMapswitchswitchS switchAwait interleaveupdatezipWithzipWith3condzipintegral derivative$fContinuousSig$fProducerSiga$fProducerSigMaybeaSigF:>:FNowWaitbindFmapFsyncsyncFmkSigFmkSigF'fromSig zipWithAwait $fProducerFa$fProducerOneShota$fProducerSigFanewNamesabstractNewtypeQmkClassP normalCon normalConExp tyVarBndrNameabstractNewtypeHasFVgetFVHasBV dependencygetBV printBindsghcStableTypesisStable isStableRec isStrictRec printMessageghcGHC.Types.ErrorSeverity SevIgnore SevWarningSevError isRattModuleadv'Var select'VarbigDelay inputValueVarextractClockVarunionVar isGhcModule getNameModuleisStrict isTemporal userFunctiontypeClassFunctiongetVar getMaybeVar getModuleFSisVarisTypemkSysLocalFromVarmkSysLocalFromExprfromRealSrcSpannoLocationInfomkAltgetAltsplitForAllTys'checkStrictDataSCxtsrcSpantcStable toSingleTick NotSupportedcheck checkBind ScopeBindScopeGetCtxtPrimHidden NoTickReason HiddenReasonRecDefLCtxtCtxtearlierhiddensrcLocrecDef stableTypes primAliasallowRecursion emptyCtxtsetCtxt modifyCtxtcheckAll System.Exit exitFailurecheckRecursiveBindsgetAllBVisStableConstrextractStableConstrcheckSCC stabilizegetScopeprimMapisPrim isPrimExpraddVars printMessage'printMessageCheckghc-prim GHC.TypesFalseAdvPrimInfoDelayAppAdvApp SelectAppBoxAppfunctionprim transform checkExpr CheckExpr recursiveSet allowRecExpoldExprverbose updateEnvstrictifyProgram GHC.MaybeMaybeGHC.Listscanldt