Copyright	(c) 2013 Ertugrul Soeylemez
License	BSD3
Maintainer	Ertugrul Soeylemez <es@ertes.de>
Safe Haskell	Safe
Language	Haskell2010

Control.Wire.Session

Contents

State delta types
- Wires with time

Description

Synopsis

State delta types

class (Monoid s, Real t) => HasTime t s | s -> t where Source #

State delta types with time deltas.

Minimal complete definition

dtime

Methods

dtime :: s -> t Source #

Extract the current time delta.

Instances

(Semigroup s, Monoid s, Real t) => HasTime t (Timed t s) Source #
Methods dtime :: Timed t s -> t Source #

newtype Session m s Source #

State delta generators as required for wire sessions, most notably to generate time deltas. These are mini-wires with the sole purpose of generating these deltas.

Constructors

Session
Fields stepSession :: m (s, Session m s)

Instances

Functor m => Functor (Session m) Source #
Methods fmap :: (a -> b) -> Session m a -> Session m b # (<$) :: a -> Session m b -> Session m a #
Applicative m => Applicative (Session m) Source #
Methods pure :: a -> Session m a # (<>) :: Session m (a -> b) -> Session m a -> Session m b # liftA2 :: (a -> b -> c) -> Session m a -> Session m b -> Session m c # (>) :: Session m a -> Session m b -> Session m b # (<*) :: Session m a -> Session m b -> Session m a #

Wires with time

data Timed t s Source #

This state delta type denotes time deltas. This is necessary for most FRP applications.

Constructors

Timed t s

Instances

(Semigroup s, Monoid s, Real t) => HasTime t (Timed t s) Source #
Methods dtime :: Timed t s -> t Source #
Functor (Timed t) Source #
Methods fmap :: (a -> b) -> Timed t a -> Timed t b # (<$) :: a -> Timed t b -> Timed t a #
Foldable (Timed t) Source #
Methods fold :: Monoid m => Timed t m -> m # foldMap :: Monoid m => (a -> m) -> Timed t a -> m # foldr :: (a -> b -> b) -> b -> Timed t a -> b # foldr' :: (a -> b -> b) -> b -> Timed t a -> b # foldl :: (b -> a -> b) -> b -> Timed t a -> b # foldl' :: (b -> a -> b) -> b -> Timed t a -> b # foldr1 :: (a -> a -> a) -> Timed t a -> a # foldl1 :: (a -> a -> a) -> Timed t a -> a # toList :: Timed t a -> [a] # null :: Timed t a -> Bool # length :: Timed t a -> Int # elem :: Eq a => a -> Timed t a -> Bool # maximum :: Ord a => Timed t a -> a # minimum :: Ord a => Timed t a -> a # sum :: Num a => Timed t a -> a # product :: Num a => Timed t a -> a #
Traversable (Timed t) Source #
Methods traverse :: Applicative f => (a -> f b) -> Timed t a -> f (Timed t b) # sequenceA :: Applicative f => Timed t (f a) -> f (Timed t a) # mapM :: Monad m => (a -> m b) -> Timed t a -> m (Timed t b) # sequence :: Monad m => Timed t (m a) -> m (Timed t a) #
(Eq s, Eq t) => Eq (Timed t s) Source #
Methods (==) :: Timed t s -> Timed t s -> Bool # (/=) :: Timed t s -> Timed t s -> Bool #
(Data s, Data t) => Data (Timed t s) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Timed t s -> c (Timed t s) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Timed t s) # toConstr :: Timed t s -> Constr # dataTypeOf :: Timed t s -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Timed t s)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Timed t s)) # gmapT :: (forall b. Data b => b -> b) -> Timed t s -> Timed t s # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Timed t s -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Timed t s -> r # gmapQ :: (forall d. Data d => d -> u) -> Timed t s -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Timed t s -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Timed t s -> m (Timed t s) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Timed t s -> m (Timed t s) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Timed t s -> m (Timed t s) #
(Ord s, Ord t) => Ord (Timed t s) Source #
Methods compare :: Timed t s -> Timed t s -> Ordering # (<) :: Timed t s -> Timed t s -> Bool # (<=) :: Timed t s -> Timed t s -> Bool # (>) :: Timed t s -> Timed t s -> Bool # (>=) :: Timed t s -> Timed t s -> Bool # max :: Timed t s -> Timed t s -> Timed t s # min :: Timed t s -> Timed t s -> Timed t s #
(Read s, Read t) => Read (Timed t s) Source #
Methods readsPrec :: Int -> ReadS (Timed t s) # readList :: ReadS [Timed t s] # readPrec :: ReadPrec (Timed t s) # readListPrec :: ReadPrec [Timed t s] #
(Show s, Show t) => Show (Timed t s) Source #
Methods showsPrec :: Int -> Timed t s -> ShowS # show :: Timed t s -> String # showList :: [Timed t s] -> ShowS #
(Semigroup s, Num t) => Semigroup (Timed t s) Source #
Methods (<>) :: Timed t s -> Timed t s -> Timed t s # sconcat :: NonEmpty (Timed t s) -> Timed t s # stimes :: Integral b => b -> Timed t s -> Timed t s #
(Semigroup s, Monoid s, Num t) => Monoid (Timed t s) Source #
Methods mempty :: Timed t s # mappend :: Timed t s -> Timed t s -> Timed t s # mconcat :: [Timed t s] -> Timed t s #

clockSession :: MonadIO m => Session m (s -> Timed NominalDiffTime s) Source #

State delta generator for a real time clock.

clockSession_ :: (Applicative m, MonadIO m) => Session m (Timed NominalDiffTime ()) Source #

Non-extending version of clockSession.

countSession Source #

Arguments

:: Applicative m
=> t	Increment size.
-> Session m (s -> Timed t s)

State delta generator for a simple counting clock. Denotes a fixed framerate. This is likely more useful than clockSession for simulations and real-time games.

countSession_ :: Applicative m => t -> Session m (Timed t ()) Source #

Non-extending version of countSession.