Specular.FRP

newtype Event a

A source of occurences.

During a frame, an Event occurs at most once with a value of type a.

Event is a functor. It is not, however, an Applicative. There is no meaningful interpretation of pure (when would the event occur?). There is an interpretation of apply (Event that fires when the input events coincide), but it's not very useful.

Instances

• Functor Event

newtype Dynamic a

Dynamic a represents a dynamically changing value of type a. The current value may be queried at any time (using current), and it's possible to be notified of changes (using changed).

Instances

• Functor Dynamic
• Apply Dynamic
• Applicative Dynamic
• Bind Dynamic
• Monad Dynamic
• (HeytingAlgebra a) => HeytingAlgebra (Dynamic a)

  This instance allows use of the Boolean operators (||) and (&&) directly on Dynamic Bool.

• (Semigroup a) => Semigroup (Dynamic a)
• (Monoid a) => Monoid (Dynamic a)

newtype Behavior a

import Partial.Unsafe (unsafeCrashWith) import Unsafe.Coerce (unsafeCoerce) Behaviors are time-changing values that can be read, but not subscribed to.

Instances

• Functor Behavior
• Apply Behavior
• Applicative Behavior
• Bind Behavior
• Monad Behavior

class MonadFRP :: (Type -> Type) -> Constraintclass (MonadEffect m, MonadCleanup m) <= MonadFRP m 

A "type class alias" for the constraints required by most FRP primitives.

Instances

• (MonadEffect m, MonadCleanup m) => MonadFRP m

uniqDynBy :: forall m a. MonadFRP m => (a -> a -> Boolean) -> Dynamic a -> m (Dynamic a)

Make a Dynamic that only changes value when the input Dynamic changes value, and the new value is not equal to the previous value with respect to the given equality test.

uniqDyn :: forall m a. MonadFRP m => Eq a => Dynamic a -> m (Dynamic a)

traceEventIO :: forall a. (a -> Effect Unit) -> Event a -> Event a

traceDynIO :: forall a. (a -> Effect Unit) -> Dynamic a -> Dynamic a

tagDyn :: forall a. Dynamic a -> Event Unit -> Event a

switch :: forall a. Dynamic (Event a) -> Event a

Make an Event that occurs when the current value of the given Dynamic (an Event) occurs.

switch (pure e) = e

subscribeEvent_ :: forall m a. MonadEffect m => MonadCleanup m => (a -> Effect Unit) -> Event a -> m Unit

subscribeDyn_ :: forall m a. MonadFRP m => (a -> Effect Unit) -> Dynamic a -> m Unit

subscribeDyn :: forall m a b. MonadFRP m => (a -> Effect b) -> Dynamic a -> m (Dynamic b)

sampleAt :: forall a b. Event (a -> b) -> Behavior a -> Event b

readDynamic :: forall m a. MonadEffect m => Dynamic a -> m a

readBehavior :: forall a. Behavior a -> Effect a

Read a value of a Behavior.

pull :: forall a m. MonadEffect m => Effect a -> m a

newEvent :: forall m a. MonadEffect m => m { event :: Event a, fire :: a -> Effect Unit }

Create an Event that can be triggered externally. Each fire will run a frame where the event occurs.

newDynamic :: forall m a. MonadEffect m => a -> m { dynamic :: Dynamic a, modify :: (a -> a) -> Effect Unit, read :: Effect a, set :: a -> Effect Unit }

effectCrash :: forall a. String -> a effectCrash msg = unsafeCoerce (_ -> unsafeCrashWith msg) Construct a new root Dynamic that can be changed from Effect-land.

newBehavior :: forall m a. MonadEffect m => a -> m { behavior :: Behavior a, set :: a -> Effect Unit }

Create a new Behavior whose value can be modified outside a frame.

never :: forall a. Event a

An Event that never occurs.

map2 :: forall a b c. (a -> b -> c) -> Dynamic a -> Dynamic b -> Dynamic c

leftmost :: forall a. Array (Event a) -> Event a

An Event that occurs when any of the events occur. If some of them occur simultaneously, the occurence value is that of the leftmost one.

latestJust :: forall m a. MonadFRP m => Dynamic (Maybe a) -> m (Dynamic (Maybe a))

Returns a Dynamic that holds the latest Just value of the input Dynamic after execution of this function. If the input currently has value Nothing, the resulting Dynamic will have the value Nothing until the input changes to a Just.

The resulting Dynamic changes when the input changes to a value that is a Just, and doesn't change when the input changes to Nothing.

holdUniqDynBy :: forall m a. MonadFRP m => (a -> a -> Boolean) -> a -> Event a -> m (Dynamic a)

holdDyn :: forall m a. MonadFRP m => a -> Event a -> m (Dynamic a)

holdDyn initialValue event returns a Dynamic that starts with initialValue, and changes to the occurence value of event when event fires

foldDynMaybe :: forall m a b. MonadFRP m => (a -> b -> Maybe b) -> b -> Event a -> m (Dynamic b)

Like foldDyn, but the Dynamic will not update if the folding function returns Nothing.

foldDyn :: forall m a b. MonadFRP m => (a -> b -> b) -> b -> Event a -> m (Dynamic b)

foldDyn f x e - Make a Dynamic that will have the initial value x, and every time e fires, its value will update by applying f to the event occurence value and the old value.

On cleanup, the Dynamic will stop updating in response to the event.

filterMapEvent :: forall a b. (a -> Maybe b) -> Event a -> Event b

filterJustEvent :: forall a. Event (Maybe a) -> Event a

filterEvent :: forall a. (a -> Boolean) -> Event a -> Event a

current :: forall a. Dynamic a -> Behavior a

The Behavior representing the current value of the Dynamic. When it is changing (the change event occurs), it has the new value.

The value of current x is always the value of the latest occurence of changed x, if it has ever occured.

changed_ :: forall a. Dynamic a -> Event Unit

An Event that fires every time the Dynamic changes.

changed :: forall a. Dynamic a -> Event a

An Event that fires with the new value every time the Dynamic changes.

attachDynWith :: forall a b c. (a -> b -> c) -> Dynamic a -> Event b -> Event c

annotated :: forall a. String -> Dynamic a -> Dynamic a

annotate :: forall m a. MonadEffect m => Dynamic a -> String -> m Unit

_subscribeEvent :: forall a. EffectFn2 (a -> Effect Unit) (Event a) Unsubscribe

class FixFRP input output | output -> input, input -> output where

Members

• fixFRP :: forall m b. MonadFRP m => (input -> m (Tuple output b)) -> m b

Instances

• FixFRP (Event a) (Event a)
• FixFRP (WeakDynamic a) (Dynamic a)
• (FixFRPRecord ro_list ri ro, RowToList ro ro_list) => FixFRP (Record ri) (Record ro)

class FixFRPRecord :: RowList Type -> Row Type -> Row Type -> Constraintclass FixFRPRecord (ro_list :: RowList Type) (ri :: Row Type) (ro :: Row Type) | ro_list -> ri ro where

Members

• fixRecord :: forall m b. MonadFRP m => Proxy ro_list -> (Record ri -> m (Tuple (Record ro) b)) -> m b

Instances

• (TypeEquals (Record ()) (Record empty)) => FixFRPRecord Nil empty empty
• (IsSymbol label, Lacks label tail_ri, Cons label input tail_ri ri, Lacks label tail_ro, Cons label output tail_ro ro, FixFRP input output, FixFRPRecord tail_ro_list tail_ri tail_ro) => FixFRPRecord (Cons label output tail_ro_list) ri ro

fixFRP_ :: forall input output m. FixFRP input output => MonadFRP m => (input -> m output) -> m Unit

fixEvent :: forall m a b. MonadFRP m => (Event a -> m (Tuple (Event a) b)) -> m b

fixDyn :: forall m a b. MonadFRP m => (WeakDynamic a -> m (Tuple (Dynamic a) b)) -> m b

withDynamic_ :: forall m a. MonadReplace m => MonadFRP m => Dynamic a -> (a -> m Unit) -> m Unit

whenJustD :: forall m a. MonadReplace m => MonadFRP m => Dynamic (Maybe a) -> (Dynamic a -> m Unit) -> m Unit

whenD :: forall m. MonadFRP m => MonadReplace m => Dynamic Boolean -> m Unit -> m Unit

Execute a monadic action in a Replaceable monad only if the given Dynamic has value true.

weakDynamic_ :: forall m. MonadReplace m => MonadFRP m => WeakDynamic (m Unit) -> m Unit

weakDynamic :: forall m a. MonadReplace m => MonadFRP m => WeakDynamic (m a) -> m (WeakDynamic a)

unlessD :: forall m. MonadFRP m => MonadReplace m => Dynamic Boolean -> m Unit -> m Unit

Execute a monadic action in a Replaceable monad only if the given Dynamic has value true.

dynamic_ :: forall m. MonadReplace m => MonadFRP m => Dynamic (m Unit) -> m Unit

dynamic :: forall m a. MonadReplace m => MonadFRP m => Dynamic (m a) -> m (Dynamic a)

newtype WeakDynamic a

A primitive similar to Dynamic. The difference is: while Dynamic always has a value, WeakDynamic has a value always after some point, but for some time after construction it may be without value.

A Dynamic can be always converted to a WeakDynamic using weaken.

Instances

• Functor WeakDynamic
• Apply WeakDynamic
• Applicative WeakDynamic
• Bind WeakDynamic
• Monad WeakDynamic

weaken :: forall a. Dynamic a -> WeakDynamic a

Convert a Dynamic to a WeakDynamic. It will have the same value as the original Dynamic, and will change whenever the original Dynamic changes.

uniqWeakDynBy :: forall m a. MonadFRP m => (a -> a -> Boolean) -> WeakDynamic a -> m (WeakDynamic a)

Make a WeakDynamic that only changes value when the input WeakDynamic changes value, and the new value is not equal to the previous value with respect to the given equality test.

unWeakDynamic :: forall a. WeakDynamic a -> Dynamic (Maybe a)

tagWeakDyn :: forall a. WeakDynamic a -> Event Unit -> Event a

switchWeakDyn :: forall a. WeakDynamic (Event a) -> Event a

Make an Event that occurs when the given WeakDynamic has a value, and the value (an Event) occurs.

subscribeWeakDyn_ :: forall m a. MonadFRP m => (a -> Effect Unit) -> WeakDynamic a -> m Unit

Invoke the handler immediately if the WeakDynamic has a value currently, and invoke it every time it changes, until cleanup.

subscribeWeakDyn :: forall m a b. MonadFRP m => (a -> Effect b) -> WeakDynamic a -> m (WeakDynamic b)

Invoke the handler immediately if the WeakDynamic has a value currently, and invoke it every time it changes, until cleanup.

holdWeakDyn :: forall m a. MonadFRP m => Event a -> m (WeakDynamic a)

Make a WeakDynamic that will have no value, but will acquire one when the Event fires. It will also change every time the Event fires.

changedW :: forall a. WeakDynamic a -> Event a

An Event that fires every time a WeakDynamic changes, with the new value.

attachWeakDynWith :: forall a b c. (a -> b -> c) -> WeakDynamic a -> Event b -> Event c