React.Halo

throwError :: forall e m a. MonadThrow e m => e -> m a

ask :: forall r m. MonadAsk r m => m r

asks :: forall a m r. MonadAsk r m => (r -> a) -> m a

Projects a value from the global context in a MonadAsk.

state :: forall s m a. MonadState s m => (s -> (Tuple a s)) -> m a

put :: forall s m. MonadState s m => s -> m Unit

Set the state.

modify_ :: forall m s. MonadState s m => (s -> s) -> m Unit

modify :: forall m s. MonadState s m => (s -> s) -> m s

Modify the state by applying a function to the current state. The returned value is the new state value.

gets :: forall a m s. MonadState s m => (s -> a) -> m a

Get a value which depends on the current state.

get :: forall s m. MonadState s m => m s

Get the current state.

lift :: forall t a m. MonadTrans t => Monad m => m a -> t m a

tell :: forall w m. MonadTell w m => w -> m Unit

parallel :: forall f m. Parallel f m => m ~> f

sequential :: forall f m. Parallel f m => f ~> m

Operator alias for Data.Tuple.Tuple (right-associative / precedence 6)

Shorthand for constructing n-tuples as nested pairs. a /\ b /\ c /\ d /\ unit becomes Tuple a (Tuple b (Tuple c (Tuple d unit)))

Operator alias for Data.Tuple.Tuple (right-associative / precedence 6)

Shorthand for constructing n-tuple types as nested pairs. forall a b c d. a /\ b /\ c /\ d /\ Unit becomes forall a b c d. Tuple a (Tuple b (Tuple c (Tuple d Unit)))

liftAff :: forall m. MonadAff m => Aff ~> m

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

data JSX :: Type

Represents rendered React VDOM (the result of calling React.createElement in JavaScript).

JSX is a Monoid:

• append
  • Merge two JSX nodes using React.Fragment.
• mempty
  • The empty node; renders nothing.

Hint: Many useful utility functions already exist for Monoids. For example, guard can be used to conditionally render a subtree of components.

Instances

• Semigroup JSX
• Monoid JSX

newtype UseHalo props state action hooks

Instances

• Newtype (UseHalo props state action hooks) _

type HookSpec props state action m = { eval :: Lifecycle props action -> HaloM props state action m Unit, initialState :: state, props :: props }

type ComponentSpec props state action m = { eval :: Lifecycle props action -> HaloM props state action m Unit, initialState :: state, render :: { props :: props, send :: action -> Effect Unit, state :: state } -> JSX }

useHalo :: forall props action state. HookSpec props state action Aff -> Hook (UseHalo props state action) (state /\ (action -> Effect Unit))

Run renderless Halo in the current component. This allows Halo to be used with other hooks and other ways of building components.

component_ :: forall action state. String -> ComponentSpec Unit state action Aff -> Effect JSX

Build a propless component by providing a name and Halo component spec.

component :: forall props action state. String -> ComponentSpec props state action Aff -> Effect (props -> JSX)

Build a component by providing a name and Halo component spec.

newtype HaloM props state action m a

The Halo evaluation monad. It lifts the HaloF algebra into a free monad.

• props are the component props
• state is the component state
• action is the set of actions that the component handles
• m is the monad used during evaluation
• a is the result type

Instances

• Functor (HaloM props state action m)
• Apply (HaloM props state action m)
• Applicative (HaloM props state action m)
• Bind (HaloM props state action m)
• Monad (HaloM props state action m)
• (Semigroup a) => Semigroup (HaloM props state action m a)
• (Monoid a) => Monoid (HaloM props state action m a)
• MonadTrans (HaloM props state action)
• (MonadEffect m) => MonadEffect (HaloM props state action m)
• (MonadAff m) => MonadAff (HaloM props state action m)
• MonadState state (HaloM props state action m)
• MonadRec (HaloM props state action m)
• (MonadAsk r m) => MonadAsk r (HaloM props state action m)
• (MonadTell w m) => MonadTell w (HaloM props state action m)
• (MonadThrow e m) => MonadThrow e (HaloM props state action m)
• Parallel (HaloAp props state action m) (HaloM props state action m)

newtype HaloAp props state action m a

The Halo parallel evaluation applicative. It lifts HaloM into a free applicative.

• props are the component props
• state is the component state
• action is the set of actions that the component handles
• m is the monad used during evaluation
• a is the result type

Instances

• Newtype (HaloAp props state action m a) _
• Functor (HaloAp props state action m)
• Apply (HaloAp props state action m)
• Applicative (HaloAp props state action m)
• Parallel (HaloAp props state action m) (HaloM props state action m)

unsubscribe :: forall props state action m. SubscriptionId -> HaloM props state action m Unit

Cancels the event subscription belonging to the SubscriptionId.

subscribe' :: forall props state action m. (SubscriptionId -> Event action) -> HaloM props state action m SubscriptionId

Same as subscribe but the event-producing logic is also passed the SuscriptionId. This is useful when events need to unsubscribe themselves.

subscribe :: forall m action state props. Event action -> HaloM props state action m SubscriptionId

Subscribe to new actions from an Event. Subscriptions will be automatically cancelled when the component unmounts.

Returns a SubscriptionId which can be used with unsubscribe to manually cancel a subscription.

props :: forall state action m props. HaloM props state action m props

Read the current props.

kill :: forall props state action m. ForkId -> HaloM props state action m Unit

Kills the process belonging to the ForkId.

hoist :: forall m' m action state props. Functor m => (m ~> m') -> (HaloM props state action m) ~> (HaloM props state action m')

Hoist (transform) the base monad of a HaloM expression.

fork :: forall props state action m. HaloM props state action m Unit -> HaloM props state action m ForkId

Start a HaloM process running independantly from the current "thread". Forks are tracked automatically and killed when the Finalize event occurs (when the component unmounts). New forks can still be created during the Finalize event, but once evaluation ends there will be no way of killing them.

Returns a ForkId for the new process.

type EvalSpec props state action m = { onAction :: action -> HaloM props state action m Unit, onFinalize :: Maybe action, onInitialize :: props -> Maybe action, onUpdate :: props -> props -> Maybe action }

A simpler interface for building the components eval function. The main lifecycle events map directly into actions, so only the action handling logic needs to be written using HaloM.

makeEval :: forall props state action m. (EvalSpec props state action m -> EvalSpec props state action m) -> Lifecycle props action -> HaloM props state action m Unit

Given an EvalSpec builder, it will return an eval function.

defaultEval :: forall m state action props. EvalSpec props state action m

The empty EvalSpec.

newtype SubscriptionId

Instances

• Eq SubscriptionId
• Ord SubscriptionId

data Lifecycle props action

The Halo lifecycle events.

• Initialize contains the initial props. It occurs when the component mounts, and only once per component.
• Update contains the previous and new props. It occurs when the component re-renders and the props have changes.
• Action contains the dispatched action. It occurs each time an action is dispatched to be eval'd, up until the Finalize event
• Finalize occurs when the component unmounts.

Constructors

• Initialize props
• Update props props
• Action action
• Finalize

newtype ForkId

Instances

• Eq ForkId
• Ord ForkId