h&VQ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM N O P Q R S T U V W X Y Z [ \ ] ^ _ ` abcdefghijklmnopqrstuv w x y z {  Safe-Inferred6PRattus.This annotation type is for internal use only.RattusUse this type to mark a Haskell function definition as a Rattus function: {-# ANN myFunction Rattus #-}>Or mark a whole module as consisting of Rattus functions only: {-# ANN module Rattus #-}If you use the latter option, you can mark exceptions (i.e. functions that should be treated as ordinary Haskell function definitions) as follows:  {-# ANN myFunction NotRattus #-}By default all 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  {-# ANN myFunction AllowLazyData #-} {-# ANN module AllowLazyData #-}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 .  Safe-Inferred)*k|Rattus"Syntax that may contain variables.}RattusCompute 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.~RattusComputes the variables that are bound by a given piece of syntax.RattusCompute the dependencies of a bag of bindings, returning a list of the strongly-connected components.~  Safe-Inferred"8 +Rattus!The set of stable built-in types.Rattus t4, this function returns the list of type variables  [a1,...,am]" for which there is a constraint  Stable ai among  C1, ... Cn.RattusChecks a top-level definition group, which is either a single non-recursive definition or a group of (mutual) recursive definitions.RattusStabilizes the given context, i.e. remove all non-stable types and any tick. This is performed on checking box, arr and guarded recursive definitions. To provide better error messages a reason has to be given as well.RattusChecks whether a given variable is in fact a Rattus primitive.RattusChecks whether a given expression is in fact a Rattus primitive.Rattus%Add variables to the current context.Rattus*Print a message with the current location.Rattus3Print a message with the current location. Returns , if the severity is  and otherwise 'True. Safe-Inferred"Rattusrecursively defined variables  Safe-Inferred"6!RattusUse this to enable Rattus' plugin, either by supplying the option -fplugin=Rattus.Plugin directly to GHC. or by including the following pragma in each source file: &{-# OPTIONS -fplugin=Rattus.Plugin #-}RattusApply the following operations to all Rattus definitions in the program:7Transform into single tick form (see SingleTick module)=Check whether lazy data types are used (see Strictify module)8Transform into call-by-value form (see Strictify module) Safe-Inferred("Rattus,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.Rattus+The "later" type modality. A value of type O a1 is a computation that produces a value of type a in the next time step. Use  and  to construct and consume -types.Rattus 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 (Str a -> Str b). But these types are not stable: [Int]) (because the list type is not strict),  Int -> Int!, (function type is not stable), O Int, Str Int.Rattus1This is the constructor for the "later" modality : 9  N E t ::  --------------------  E delay t :: O Rattus0This is the eliminator for the "later" modality : ;  E t :: O  ---------------------  N ' E adv t :: Rattus2This is the constructor for the "stable" modality : 8 L E t ::  --------------------  E box t :: Box  c --------------------  E arr t :: a b cRattus+Get the first element (= head) of a stream.?RattusGet the tail of a stream, i.e. the remainder after removing the first element.@Rattus-Apply a function to each element of a stream.ARattus>Construct a stream that has the same given value at each step.BRattus Variant of A that allows any type a% as argument as long as it is boxed.CRattusConstruct a stream by repeatedly applying a function to a given start element. That is, unfold (box f) x will produce the stream x ::: f x ::: f (f x) ::: ...DRattusSimilar to Haskell's . scan (box f) x (v1 ::: v2 ::: v3 ::: ... ) == (x `f` v1) ::: ((x `f` v1) `f` v2) ::: ... Note: Unlike , D starts with x f v1, not x.ERattusE is a composition of @ and D: "scanMap f g x === map g . scan f xFRattusF is similar to E but takes two input streams.GRattus Similar to  on Haskell lists.HRattus Similar to  on Haskell lists.IRattus;Filter out elements from a stream according to a predicate.JRattusGiven a value a and a stream as, this function produces a stream that behaves like KRattus Given a list  [a1, ..., an] of elements and a stream xs this function constructs a stream that starts with the elements  a1, ..., an, and then proceeds as xs. In particular, this means that the ith element of the original stream xs< is the (i+n)th element of the new stream. In other words  shiftMany$ behaves like repeatedly applying shift for each element in the list. LRattusCalculates an approximation of an integral of the stream of type Str a( (the y-axis), where the stream of type Str s provides the distance between measurements (i.e. the distance along the y axis).<=>?@ABCDEFGHIJKL@>?ABJKDEF<=GHCIL  Safe-InferredA< MRattus.A future may either be available now or later.PRattusApply a function to the value of the future (if it ever occurs).QRattus A future that will never happen.RRattus switch s e will behave like s until the future e is available with value s'", in which case it will behave as s'.RattusTurn a stream of #s into a future. The future will occur whenever the stream has a value of the form Just' v!, and the future then has value v.SRattusTurn a stream of #s into a stream of futures. Each such future behaves as if created by .TRattusLike R= but works on stream functions instead of streams. That is, switchTrans s e will behave like s until the future e occurs with value s'#, in which case it will behave as s'.RattusHelper function for T.RattusHelper function for U.RattusHelper function for U.URattusSynchronise two futures. The resulting future occurs after both futures have occurred (coinciding with whichever future occurred last.VRattusTrigger a future as soon as the given predicate turns true on the given stream. The value of the future is the same as that of the stream at that time.WRattus:Trigger a future as soon as the given function produces a $ value. MNOPQRSTUVW PQRTSMNOUVW  Safe-InferredFv XRattusEvents are simply streams of #s.YRattusApply a function to the values of the event (every time it occurs).ZRattusAn event that will never occur.[Rattus switch s e will behave like s but switches to s'$ every time the event e occurs with some value s'@.\Rattus combine f s e is similar to  switch s e+, but instead of switching to new streams s' every time the event e occurs with some value s', the new stream s'& is combined with the current stream s using zipWith f s' s.]RattusLike [= but works on stream functions instead of streams. That is, switchTrans s e will behave like s but switches to s'$ every time the event e occurs with some value s'@.RattusHelper function for ].^RattusLike ] but takes a delayed event as input, which allows the switch to incorporate feedback from itself.RattusHelper function for ^._RattusTrigger an event as every time the given predicate turns true on the given stream. The value of the event is the same as that of the stream at that time.`Rattus:Trigger an event every time the given function produces a $ value. XYZ[\]^_` YZ[]^\X_` Safe-Inferred.OcaRattus%Signal functions from inputs of type a to outputs of type b.bRattus#Run a signal function for one step.cRattus/The identity signal function that does nothing.dRattusCompose two signal functions.eRattusCompute the integral of a signal. The first argument is the offset.fRattus switch s f behaves like s composed with arr fst until s produces a value of the form Just' c> in the second component. From then on it behaves like $f c@.gRattus rSwitch s behaves like s2, but every time the second input is of the form Just' s' it will change behaviour to s'.hRattusConstant signal function.iRattusThe output at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.jRattusInsert a sample in the output, and from that point on, behave like the given signal function.Note: The type of -:> is different from Yampa's: The second argument must be delayed (or boxed).kRattusThe input at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.lRattus9Apply a function to the first output value at time zero.mRattus8Apply a function to the first input value at time zero.nRattus'Override initial value of input signal.Rattus9Lift a function to a signal function (applied pointwise).Note: The type of is different from Yampa's: The function argument must be boxed.Rattus/Apply a signal function to the first component.Rattus0Apply a signal function to the second component.Rattus'Apply two signal functions in parallel.Rattus9Apply two signal functions in parallel on the same input.oRattus9Loop with an initial value for the signal being fed back.Note: The type of loopPre+ is different from Yampa's as we need the O type here.pRattus$Precomposition with a pure function.qRattus%Postcomposition with a pure function.rRattus?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` a b c V d e f g h i j k V d e l g m i jnopq`erstuvwxyz{|}~                               V      #Rattus-0.5.1-6knlTrMZ6604VfwaU1FsxB Rattus.YampaRattus.Plugin.Annotation Rattus.PluginRattus.Primitives Rattus.Arrow Rattus.StrictRattus Rattus.Stream Rattus.Future Rattus.EventRattus.ToHaskellRattus.Plugin.DependencyRattus.Plugin.UtilsRattus.Plugin.StrictifyRattus.Plugin.StableSolverRattus.Plugin.SingleTickRattus.Plugin.ScopeCheckRattus.Plugin.CheckSingleTick Control.ArrowArrowarrPreludezipWithzipbaseControl.Category>>> InternalAnn ExpectError ExpectWarning NotRattus AllowLazyDataAllowRecursion$fDataInternalAnn$fShowInternalAnn$fEqInternalAnn$fOrdInternalAnn $fDataRattus $fShowRattus $fOrdRattus $fEqRattuspluginBoxOStabledelayadvboxunboxarrBoxfirstsecond***&&&returnA:*Maybe'Just'Nothing'ListNil:! listDelayinit'reverse' listToMaybe'+++ mapMaybe'maybe'fst'snd' $fFunctorList$fFoldableList$fShow:* $fFunctor:*$fVectorSpace:*a<#><##|#||##box'Str:::hdtlmapconstconstBoxunfoldscanscanMapscanMap2filtershift shiftManyintegralFutureNowWaitneverswitchwhenJust switchTransawaittrigger triggerMapEventcombine dswitchTransSFstepSFidentitycomposerSwitchconstant-->-:>>---=>>=- initiallyloopPre^>>>>^<<^^<< $fArrowSF$fCategoryTYPESFTrans runTransducerrunSFtoStrfromStrHasFVgetFVHasBV dependencygetBV printBindsghcStableTypesisStable isStableRec isStrictRecghcGHC.Types.ErrorSeveritySevDumpSevErrorSevFatalSevInfoSevInteractive SevOutput SevWarningisType printMessage isRattModule isGhcModule getNameModule isTemporalisStrictsplitForAllTys' userFunctionmkSysLocalFromVarmkSysLocalFromExprfromRealSrcSpannoLocationInfomkAltgetAlt strictifyExprcheckStrictDataSCxtsrcSpantcStable toSingleTick NotSupportedcheck checkBind ScopeBindScopeGetCtxtPrimHidden NoTickReason HiddenReasonRecDefLCtxtCtxtcurrentearlierhiddensrcLocrecDef stableTypes primAliasDelay stabilizedallowRecursion emptyCtxtsetCtxt modifyCtxtcheckAll System.Exit exitFailure filterBindscheckRecursiveBindsgetAllBVisStableConstrextractStableConstrcheckSCC stabilizegetScopeprimMapisPrim isPrimExpraddVars printMessage'printMessageCheckghc-prim GHC.TypesFalse CheckExpr recursiveSet allowRecExpoldExpr fatalErrorverbose checkExprstrictifyProgramGHC.Basereturn GHC.MaybeMaybeGHC.Listscanl firstJust switchTrans'await1await2 dswitchTrans'arrPrim firstPrim secondPrim parSplitPrim parFanOutPrim