FRP.Timeless

Reexports

module FRP.Timeless.Run

High level FRP

type Stream a b = Signal IO (Maybe a) (Maybe b)

A Stream of discrete events.

type Cell a b = Signal IO a b

A Cell of continuous value.

Cells must not be inhibited

type StreamCell a b = Signal IO (Maybe a) b

FRP Primitives

sourceC :: IO b -> CellSource b

sinkC :: (a -> IO ()) -> CellSink a

sourceS :: IO (Maybe b) -> StreamSource b

sinkS :: (a -> IO ()) -> StreamSink a

mergeS :: ((a, a) -> a) -> Signal IO (Maybe a, Maybe a) (Maybe a)

Merges two Stream. When simultaneous, use the merge function

orElse :: Signal IO (Maybe b, Maybe b) (Maybe b)

Merges two Stream with precedence to first.

hold :: a -> StreamCell a a

Holds a discrete value to be continuous. An initial value must be given

filterS :: (a -> Bool) -> Stream a a

Filters stream of event. TODO: In future, might implement Foldable

snapshot :: ((a, b) -> c) -> Signal IO (Maybe a, b) (Maybe c)

Takes a snapshot of b when an event a comes. Meanwhile, transform the Stream with the Cell value

sample :: Signal IO (Maybe a, b) (Maybe b)

This conviniently just samples a Cell

state :: s' -> ((a, s') -> s') -> Signal IO (Maybe a) s'

A state block, updates on event. Note that this can be constructed with Signal directly, but we are using primitives instead, for easy reasoning

zipS :: Signal m (Maybe a, Maybe b) (Maybe (a, b))

zipS3 :: Signal m (Maybe a, Maybe b, Maybe c) (Maybe (a, b, c))

zipS4 :: Signal m (Maybe a, Maybe b, Maybe c, Maybe d) (Maybe (a, b, c, d))

zipS5 :: Signal m (Maybe a, Maybe b, Maybe c, Maybe d, Maybe e) (Maybe (a, b, c, d, e))

zipS6 :: Signal m (Maybe a, Maybe b, Maybe c, Maybe d, Maybe e, Maybe f) (Maybe (a, b, c, d, e, f))

zipS7 :: Signal m (Maybe a, Maybe b, Maybe c, Maybe d, Maybe e, Maybe f, Maybe g) (Maybe (a, b, c, d, e, f, g))

External

module Control.Applicative

module Control.Arrow

module Control.Category

module Data.Time.Clock