module FRP.Timeless.Prefab.Processing
(
sample
, snapshot
, integrateM
, integrate
, wait
, waitWith
, (<=>)
, unless'
, when'
)
where
import Control.Arrow
import Control.Applicative
import Data.Monoid
import Control.Monad
import Control.Monad.IO.Class
import FRP.Timeless.Signal
import FRP.Timeless.Session
import FRP.Timeless.Prefab.Primitive
import qualified Debug.Trace as D
sample :: (Monad m) => Signal s m (Bool, a) a
sample = mkSFN f
where
f (_, a) = (a, mkSFN $ f' a)
f' a (False, _) = (a, mkSFN $ f' a)
f' a (True, a') = (a', mkSFN $ f' a')
snapshot :: (Monad m) => Signal s m (Bool, a) a
snapshot = sample
integrateM :: (Monad m, Monoid b, HasTime t s) =>
b
-> (s -> a -> b)
-> Signal s m a b
integrateM b0 f = mkSF $ g b0
where
g b0 ds a = let db = f ds a
b1 = b0 <> db
in (b1, mkSF $ g b1)
integrate :: (Monad m, Num a, HasTime t s) =>
a
-> (s -> a -> a)
-> Signal s m a a
integrate a0 f = integrateM (Sum a0) (\s a -> Sum $ f s a) >>> arr getSum
wait :: (HasTime t s, Monad m) => Double -> Signal s m a a
wait t =
mkPure $ \ds a ->
let dt = realToFrac $ dtime ds in
if | t < 0 -> (Nothing, mkEmpty)
| otherwise -> (Just a, wait $ t dt)
waitWith :: (HasTime t s, Monad m) => b -> Double -> Signal s m a b
waitWith b t = pure b >>> wait t
(<=>) :: Monad m =>
Maybe b
-> Maybe b
-> Signal s m Bool b
mb1 <=> mb2 = mkPureN $ \case
True -> (mb1, mb1 <=> mb2)
False -> (mb2, mb1 <=> mb2)
infix 3 <=>
unless' :: Monad m =>
(a -> Bool)
-> Signal s m a a
unless' pred = mkPureN $ \a ->
if | pred a -> (Just a, unless' pred)
| otherwise -> (Nothing, unless' pred)
when' :: Monad m =>
(a -> Bool)
-> Signal s m a a
when' pred = mkPureN $ \a ->
if | pred a -> (Just a, when' pred)
| otherwise -> (Nothing, when' pred)