Halogen

type HalogenIO f o m = { query :: f ~> m, subscribe :: Consumer o m Unit -> m Unit }

A record produced when the root component in a Halogen UI has been run. query allows external sources to query the root component and subscribe allows external consumers to receive messages raised by the root component.

type HTML p i = HTML p (i Unit)

A specialised version of the Halogen.HTML.Core.HTML type where i is * -> * kinded to match the kind of a component query algebra.

type IProp r i = IProp r (i Unit)

A specialised version of the Halogen.HTML.Properties.IProp type where i is * -> * kinded to match the kind of a component query algebra.

defer :: forall a. (Unit -> a) -> Lazy a

Defer a computation, creating a Lazy value.

type ParentLifecycleComponentSpec h s f g p i o m = { eval :: f ~> (HalogenM s f g p o m), finalizer :: Maybe (f Unit), initialState :: i -> s, initializer :: Maybe (f Unit), receiver :: i -> Maybe (f Unit), render :: s -> h (ComponentSlot h g m p (f Unit)) (f Unit) }

A spec for a parent component, including lifecycle inputs.

• h is the type that will be rendered by the component, usually HTML
• s is the component's state
• f is the query algebra for the component itself
• g is the query algebra for child components
• p is the slot type for addressing child components
• o is the type for the component's output messages
• m is the monad used for non-component-state effects

type ParentHTML f g p m = HTML (ComponentSlot HTML g m p (f Unit)) (f Unit)

A convenience synonym for the output type of a render function, for a parent component that renders HTML.

type ParentDSL = HalogenM

A synonym for just HalogenM. Provided for consistency with ComponentDSL in the non-parent-component case.

type ParentComponentSpec h s f g p i o m = { eval :: f ~> (HalogenM s f g p o m), initialState :: i -> s, receiver :: i -> Maybe (f Unit), render :: s -> h (ComponentSlot h g m p (f Unit)) (f Unit) }

A spec for a component.

• h is the type that will be rendered by the component, usually HTML
• s is the component's state
• f is the query algebra for the component itself
• g is the query algebra for child components
• p is the slot type for addressing child components
• o is the type for the component's output messages
• m is the monad used for non-component-state effects

type LifecycleComponentSpec h s f i o m = { eval :: f ~> (ComponentDSL s f o m), finalizer :: Maybe (f Unit), initialState :: i -> s, initializer :: Maybe (f Unit), receiver :: i -> Maybe (f Unit), render :: s -> h Void (f Unit) }

A spec for a component with no possible children, including lifecycle inputs.

• h is the type that will be rendered by the component, usually HTML
• s is the component's state
• f is the query algebra
• i is the input value type that will be mapped to an f whenever the parent of this component renders
• o is the type for the component's output messages
• m is the monad used for non-component-state effects

type ComponentSpec h s f i o m = { eval :: f ~> (ComponentDSL s f o m), initialState :: i -> s, receiver :: i -> Maybe (f Unit), render :: s -> h Void (f Unit) }

A spec for a component with no possible children.

• h is the type that will be rendered by the component, usually HTML
• s is the component's state
• f is the query algebra
• i is the input value type that will be mapped to an f whenever the parent of this component renders
• o is the type for the component's output messages
• m is the monad used for non-component-state effects

data ComponentSlot (h :: Type -> Type -> Type) (g :: Type -> Type) (m :: Type -> Type) p q

Instances

• Bifunctor (ComponentSlot h g m)
• Functor (ComponentSlot h g m p)

type ComponentHTML f = HTML Void (f Unit)

A convenience synonym for the output type of a render function, for a childless component that renders HTML.

type ComponentDSL s f = HalogenM s f (Const Void) Void

A synonym for HalogenM with some type parameters populated that are not relevant for childless components.

type Component' h s f g p i o m = { eval :: f ~> (HalogenM s f g p o m), finalizer :: Maybe (f Unit), initialState :: i -> s, initializer :: Maybe (f Unit), mkOrdBox :: p -> OrdBox p, receiver :: i -> Maybe (f Unit), render :: s -> h (ComponentSlot h g m p (f Unit)) (f Unit) }

The "private" type for a component.

• h is the type that will be rendered by the component, usually HTML
• s is the component's state
• f is the query algebra for the component itself
• g is the query algebra for child components
• p is the slot type for addressing child components
• i is the input value type that will be mapped to an f whenever the parent of this component renders
• o is the type for the component's output messages
• m is the monad used for non-component-state effects

data Component (h :: Type -> Type -> Type) (f :: Type -> Type) i o (m :: Type -> Type)

The "public" type for a component, with details of the component internals existentially hidden.

• h is the type that will be rendered by the component, usually HTML
• f is the query algebra
• i is the input value type that will be mapped to an f whenever the parent of this component renders
• o is the type for the component's output messages
• m is the monad used for non-component-state effects

unComponentSlot :: forall r q p m g h. (forall o j z. p -> Component h z j o m -> j -> (j -> Maybe (g Unit)) -> (o -> Maybe q) -> (forall x. g x -> Maybe (z x)) -> r) -> ComponentSlot h g m p q -> r

unComponent :: forall r m o i f h. (forall p g s. Component' h s f g p i o m -> r) -> Component h f i o m -> r

Exposes the inner details of a component to a function to produce a new result. The inner details will not be allowed to be revealed in the result of the function - the compiler will complain about an escaped skolem.

parentComponent :: forall m o i p g f s h. Ord p => ParentComponentSpec h s f g p i o m -> Component h f i o m

Builds a component that allows for children.

mkComponentSlot :: forall o q j p m z g h. p -> (Component h z j o m) -> j -> (j -> Maybe (g Unit)) -> (o -> Maybe q) -> (forall x. g x -> Maybe (z x)) -> ComponentSlot h g m p q

mkComponent :: forall m o i p g f s h. Component' h s f g p i o m -> Component h f i o m

Makes a Component from a Component', existentially hiding details about the component's state and potential children.

lifecycleParentComponent :: forall m o i p g f s h. Ord p => ParentLifecycleComponentSpec h s f g p i o m -> Component h f i o m

Builds a component with lifecycle inputs that allows for children.

lifecycleComponent :: forall m o i f s h. Bifunctor h => LifecycleComponentSpec h s f i o m -> Component h f i o m

Builds a component with lifecycle inputs and no possible children.

hoist :: forall m' m o i f h. Bifunctor h => Functor m' => (m ~> m') -> Component h f i o m -> Component h f i o m'

Changes the component's m type. A use case for this would be to interpret some Free monad as Aff so the component can be used with runUI.

component :: forall m o i f s h. Bifunctor h => ComponentSpec h s f i o m -> Component h f i o m

Builds a component with no possible children.

newtype PropName value

A type-safe wrapper for property names.

The phantom type value describes the type of value which this property requires.

Constructors

• PropName String

Instances

• Newtype (PropName value) _
• Eq (PropName value)
• Ord (PropName value)
• Generic (PropName value)

newtype Namespace

Constructors

• Namespace String

Instances

• Newtype Namespace _
• Eq Namespace
• Ord Namespace
• Generic Namespace

newtype ElemName

Constructors

• ElemName String

Instances

• Newtype ElemName _
• Eq ElemName
• Ord ElemName
• Generic ElemName

newtype ClassName

A wrapper for strings which are used as CSS classes.

Constructors

• ClassName String

Instances

• Newtype ClassName _
• Eq ClassName
• Ord ClassName
• Semigroup ClassName
• Generic ClassName

newtype AttrName

A type-safe wrapper for attribute names.

Constructors

• AttrName String

Instances

• Newtype AttrName _
• Eq AttrName
• Ord AttrName
• Generic AttrName

data SubscribeStatus

The status of an EventSource subscription. When a query raised by an EventSource evaluates to Done the producer will be unsubscribed from.

Constructors

• Listening
• Done

Instances

• Eq SubscribeStatus
• Ord SubscribeStatus

type Request f a = (a -> a) -> f a

Type synonym for an "request" - a request can cause effects as well as fetching some information from a component.

In a query algebra, an action is any constructor that carries the algebra's type variable as the return value of a function. For example:

data Query a = SomeRequest (Boolean -> a)

newtype RefLabel

Constructors

• RefLabel String

Instances

• Newtype RefLabel _
• Eq RefLabel
• Ord RefLabel

newtype HalogenM s (f :: Type -> Type) g p o m a

Constructors

• HalogenM (Free (HalogenF s f g p o m) a)

Instances

• Functor (HalogenM s f g p o m)
• Apply (HalogenM s f g p o m)
• Applicative (HalogenM s f g p o m)
• Bind (HalogenM s f g p o m)
• Monad (HalogenM s f g p o m)
• (MonadEff eff m) => MonadEff eff (HalogenM s f g p o m)
• (MonadAff eff m) => MonadAff eff (HalogenM s f g p o m)
• Parallel (HalogenAp s f g p o m) (HalogenM s f g p o m)
• MonadTrans (HalogenM s f g p o)
• MonadRec (HalogenM s f g p o m)
• MonadState s (HalogenM s f g p o m)
• (MonadAsk r m) => MonadAsk r (HalogenM s f g p o m)
• (MonadTell w m) => MonadTell w (HalogenM s f g p o m)

data HalogenF s (f :: Type -> Type) g p o m a

The Halogen component algebra

Constructors

• State (s -> Tuple a s)
• Subscribe (EventSource f m) a
• Lift (m a)
• Halt String
• GetSlots (List p -> a)
• CheckSlot p (Boolean -> a)
• ChildQuery p (Coyoneda g a)
• Raise o a
• Par (HalogenAp s f g p o m a)
• Fork (Fork (HalogenM s f g p o m) a)
• GetRef RefLabel (Maybe Foreign -> a)

Instances

• (Functor m) => Functor (HalogenF s f g p o m)

newtype EventSource f m

type Action f = Unit -> f Unit

Type synonym for an "action" - An action only causes effects and has no result value.

In a query algebra, an action is any constructor that carries the algebra's type variable as a value. For example:

data Query a
  = SomeAction a
  | SomeOtherAction String a
  | NotAnAction (Boolean -> a)

Both SomeAction and SomeOtherAction have a as a value so they are considered actions, whereas NotAnAction has a as the result of a function so is considered to be a "request" (see below).

subscribe :: forall m o p g f s. EventSource f m -> HalogenM s f g p o m Unit

Provides a way of having a component subscribe to an EventSource from within an Eval function.

request :: forall a f. Request f a -> f a

Takes a data constructor of query algebra f and creates a request.

For example:

data Query a = GetTickCount (Int -> a)

getTickCount :: forall o eff. HalogenIO Query o (Aff (HalogenEffects eff)) -> Aff (HalogenEffects eff) Int
getTickCount app = app.query (request GetTickCount)

raise :: forall m o p g f s. o -> HalogenM s f g p o m Unit

Raises an output message for the component.

queryAll' :: forall a m o p' p g' g f s. Ord p => Eq p' => ChildPath g g' p p' -> g a -> HalogenM s f g' p' o m (Map p a)

Sends a query to all children of a specific type within a component, using a ChildPath to discriminate the type of child component to query.

queryAll :: forall a m o p g f s. Ord p => g a -> HalogenM s f g p o m (Map p a)

Sends a query to all children of a component.

query' :: forall a o p' p m g' g f s. Eq p' => ChildPath g g' p p' -> p -> g a -> HalogenM s f g' p' o m (Maybe a)

Sends a query to a child of a component at the specified slot, using a ChildPath to discriminate the type of child component to query.

query :: forall a m o p g f s. Eq p => p -> g a -> HalogenM s f g p o m (Maybe a)

Sends a query to a child of a component at the specified slot.

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 the state by applying a function to the current state.

mkQuery :: forall a m o p g f s. Eq p => p -> g a -> HalogenM s f g p o m a

liftEff :: forall eff m a. MonadEff eff m => Eff eff a -> m a

liftAff :: forall eff m a. MonadAff eff m => Aff eff a -> m a

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

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

Get a value which depends on the current state.

getSlots :: forall m o p g f s. HalogenM s f g p o m (List p)

getRef :: forall m o p g f s. RefLabel -> HalogenM s f g p o m (Maybe Foreign)

getHTMLElementRef :: forall m o p g f s. RefLabel -> HalogenM s f g p o m (Maybe HTMLElement)

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

Get the current state.

eventSource_ :: forall eff m f. MonadAff (avar :: AVAR | eff) m => (Eff (avar :: AVAR | eff) Unit -> Eff (avar :: AVAR | eff) Unit) -> f SubscribeStatus -> EventSource f m

Creates an EventSource for a callback that accepts no arguments.

• The first argument is the function that attaches the listener.
• The second argument is the query to raise whenever the listener is triggered.

eventSource :: forall eff a m f. MonadAff (avar :: AVAR | eff) m => ((a -> Eff (avar :: AVAR | eff) Unit) -> Eff (avar :: AVAR | eff) Unit) -> (a -> Maybe (f SubscribeStatus)) -> EventSource f m

Creates an EventSource for a callback that accepts one argument.

• The first argument is the function that attaches the listener.
• The second argument is a handler that optionally produces a value in f.

checkSlot :: forall m o p g f s. p -> HalogenM s f g p o m Boolean

action :: forall f. Action f -> f Unit

Takes a data constructor of query algebra f and creates an action.

For example:

data Query a = Tick a

sendTick :: forall o eff. HalogenIO Query o (Aff (HalogenEffects eff)) -> Aff (HalogenEffects eff) Unit
sendTick app = app.query (action Tick)