Safe Haskell	None
Language	Haskell98

FRP.Yampa.Core

Contents

Signal function
Stateless combinators
Stateful combinators
- Switching upon certain events
- Time (NOTE: integral 1 over time. Not really necessary.)

Synopsis

Signal function

data SF a b #

Signal function that transforms a signal carrying values of some type a into a signal carrying values of some type b. You can think of it as (Signal a -> Signal b). A signal is, conceptually, a function from Time to value.

Instances

Arrow SF #
Methods arr :: (b -> c) -> SF b c # first :: SF b c -> SF (b, d) (c, d) # second :: SF b c -> SF (d, b) (d, c) # (***) :: SF b c -> SF b' c' -> SF (b, b') (c, c') # (&&&) :: SF b c -> SF b c' -> SF b (c, c') #
ArrowChoice SF #
Methods left :: SF b c -> SF (Either b d) (Either c d) # right :: SF b c -> SF (Either d b) (Either d c) # (+++) :: SF b c -> SF b' c' -> SF (Either b b') (Either c c') # (\|\|\|) :: SF b d -> SF c d -> SF (Either b c) d #
ArrowLoop SF #
Methods loop :: SF (b, d) (c, d) -> SF b c #
Category * SF #
Methods id :: cat a a # (.) :: cat b c -> cat a b -> cat a c #

Stateless combinators

iPre :: a -> SF a a #

Initialized delay operator.

arr :: Arrow a => forall b c. (b -> c) -> a b c #

Lift a function to an arrow.

(>>>) :: Category k cat => cat a b -> cat b c -> cat a c infixr 1 #

Left-to-right composition

first :: Arrow a => forall b c d. a b c -> a (b, d) (c, d) #

Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.

Stateful combinators

loop :: ArrowLoop a => forall b d c. a (b, d) (c, d) -> a b c #

integral :: VectorSpace a s => SF a a #

Integration using the rectangle rule.

Switching upon certain events

data Event a #

A single possible event occurrence, that is, a value that may or may not occur. Events are used to represent values that are not produced continuously, such as mouse clicks (only produced when the mouse is clicked, as opposed to mouse positions, which are always defined).

Constructors

NoEvent
Event a

Instances

Monad Event #	Monad instance
Methods (>>=) :: Event a -> (a -> Event b) -> Event b # (>>) :: Event a -> Event b -> Event b # return :: a -> Event a # fail :: String -> Event a #
Functor Event #	Functor instance (could be derived).
Methods fmap :: (a -> b) -> Event a -> Event b # (<$) :: a -> Event b -> Event a #
Applicative Event #	Applicative instance (similar to `Maybe`).
Methods pure :: a -> Event a # (<>) :: Event (a -> b) -> Event a -> Event b # (>) :: Event a -> Event b -> Event b # (<*) :: Event a -> Event b -> Event a #
Alternative Event #	Alternative instance
Methods empty :: Event a # (<\|>) :: Event a -> Event a -> Event a # some :: Event a -> Event [a] # many :: Event a -> Event [a] #
Eq a => Eq (Event a) #	Eq instance (equivalent to derived instance)
Methods (==) :: Event a -> Event a -> Bool # (/=) :: Event a -> Event a -> Bool #
Ord a => Ord (Event a) #	Ord instance (equivalent to derived instance)
Methods compare :: Event a -> Event a -> Ordering # (<) :: Event a -> Event a -> Bool # (<=) :: Event a -> Event a -> Bool # (>) :: Event a -> Event a -> Bool # (>=) :: Event a -> Event a -> Bool # max :: Event a -> Event a -> Event a # min :: Event a -> Event a -> Event a #
Show a => Show (Event a) #
Methods showsPrec :: Int -> Event a -> ShowS # show :: Event a -> String # showList :: [Event a] -> ShowS #
NFData a => NFData (Event a) #	NFData instance
Methods rnf :: Event a -> () #
Forceable a => Forceable (Event a) #	Forceable instance
Methods force :: Event a -> Event a #

switch :: SF a (b, Event c) -> (c -> SF a b) -> SF a b #

Basic switch.

By default, the first signal function is applied.

Whenever the second value in the pair actually is an event, the value carried by the event is used to obtain a new signal function to be applied *at that time and at future times*.

Until that happens, the first value in the pair is produced in the output signal.

Important note: at the time of switching, the second signal function is applied immediately. If that second SF can also switch at time zero, then a double (nested) switch might take place. If the second SF refers to the first one, the switch might take place infinitely many times and never be resolved.

Remember: The continuation is evaluated strictly at the time of switching!

Time (NOTE: integral 1 over time. Not really necessary.)

type Time = Double #

Time is used both for time intervals (duration), and time w.r.t. some agreed reference point in time.

time :: SF a Time #

Alternative name for localTime.