Safe Haskell	None
Language	Haskell2010

Rattus

Contents

Rattus language primitives
Strict data types
Annotation
Applicative operators
box for stable types

Description

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.

Synopsis

module Rattus.Primitives
module Rattus.Strict
data Rattus
- = Rattus
- | NotRattus
- | AllowLazyData
(|#|) :: Box (a -> b) -> Box a -> Box b
(|##) :: Stable a => Box (a -> b) -> a -> Box b
(<#>) :: O (a -> b) -> O a -> O b
(<##) :: Stable a => O (a -> b) -> a -> O b
box' :: Stable a => a -> Box a

Rattus language primitives

module Rattus.Primitives

Strict data types

module Rattus.Strict

Annotation

data Rattus Source #

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 #-}

Constructors

Rattus
NotRattus
AllowLazyData

Instances

Instances details

Eq Rattus Source #
Instance details Defined in Rattus.Plugin.Annotation Methods (==) :: Rattus -> Rattus -> Bool # (/=) :: Rattus -> Rattus -> Bool #
Data Rattus Source #
Instance details 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 Source #
Instance details Defined in Rattus.Plugin.Annotation Methods showsPrec :: Int -> Rattus -> ShowS # show :: Rattus -> String # showList :: [Rattus] -> ShowS #

Applicative operators

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

Applicative operator for Box.

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

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

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

Applicative operator for O.

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

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

box for stable types

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

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