Rattus

The bare-bones Rattus language. To program with streams and events, you can use Rattus.Stream and Rattus.Events; to program with Yampa-style signal functions, you can use Rattus.Yampa.

Rattus language primitives

module Rattus.Primitives

Strict data types

module Rattus.Strict

Annotation

data Rattus

Use 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 AllowLazyData

{-# 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 AllowRecursion.

Constructors

Rattus

NotRattus

AllowLazyData

AllowRecursion

Instances

Data Rattus

Defined in Rattus.Plugin.Annotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rattus -> c Rattus

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Rattus

toConstr :: Rattus -> Constr

dataTypeOf :: Rattus -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Rattus)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rattus)

gmapT :: (forall b. Data b => b -> b) -> Rattus -> Rattus

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rattus -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rattus -> r

gmapQ :: (forall d. Data d => d -> u) -> Rattus -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rattus -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rattus -> m Rattus

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rattus -> m Rattus

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rattus -> m Rattus

Show Rattus

Defined in Rattus.Plugin.Annotation

Methods

showsPrec :: Int -> Rattus -> ShowS

show :: Rattus -> String

showList :: [Rattus] -> ShowS

Eq Rattus

Defined in Rattus.Plugin.Annotation

Methods

(==) :: Rattus -> Rattus -> Bool

(/=) :: Rattus -> Rattus -> Bool

Ord Rattus

Defined in Rattus.Plugin.Annotation

Methods

compare :: Rattus -> Rattus -> Ordering

(<) :: Rattus -> Rattus -> Bool

(<=) :: Rattus -> Rattus -> Bool

(>) :: Rattus -> Rattus -> Bool

(>=) :: Rattus -> Rattus -> Bool

max :: Rattus -> Rattus -> Rattus

min :: Rattus -> Rattus -> Rattus

Applicative operators

(|#|) :: Box (a -> b) -> Box a -> Box b

Applicative operator for Box.

(|##) :: Stable a => Box (a -> b) -> a -> Box b

Variant of |#| where the argument is of a stable type..

(<#>) :: O (a -> b) -> O a -> O b

Applicative operator for O.

(<##) :: Stable a => O (a -> b) -> a -> O b

Variant of <#> where the argument is of a stable type..

box for stable types

box' :: Stable a => a -> Box a

Variant of box for stable types that can be safely used nested in recursive definitions or in another box.