Concur.Core

type WidgetStepRecord v a = { cont :: Aff a, view :: v }

newtype WidgetStep v a

Constructors

• WidgetStep (Effect (Either a (WidgetStepRecord v a)))

Instances

• Functor (WidgetStep v)

unWidgetStep :: forall a v. WidgetStep v a -> Effect (Either a (WidgetStepRecord v a))

displayStep :: forall v a. v -> WidgetStep v a

newtype Widget v a

Constructors

• Widget (Free (WidgetStep v) a)

Instances

• Functor (Widget v)
• Bind (Widget v)
• Applicative (Widget v)
• Apply (Widget v)
• Monad (Widget v)
• MonadRec (Widget v)
• ShiftMap (Widget v) (Widget v)
• (Monoid v) => MultiAlternative (Widget v)
• (Monoid v) => Semigroup (Widget v a)
• (Monoid v) => Monoid (Widget v a)
• (Monoid v) => Alt (Widget v)
• (Monoid v) => Plus (Widget v)
• (Monoid v) => Alternative (Widget v)
• (Monoid v) => MonadEffect (Widget v)
• (Monoid v) => MonadAff (Widget v)

unWidget :: forall a v. Widget v a -> Free (WidgetStep v) a

flipEither :: forall b a. Either a b -> Either b a

resume :: forall a f. Functor f => Free f a -> Either a (f (Free f a))

pulse :: forall v. Monoid v => Widget v Unit

mapView :: forall v2 v1 a. (v1 -> v2) -> Widget v1 a -> Widget v2 a

mapViewStep :: forall a v2 v1. (v1 -> v2) -> WidgetStep v1 a -> WidgetStep v2 a

display :: forall v a. v -> Widget v a

effAction :: forall v a. Effect a -> Widget v a

unsafeBlockingEffAction :: forall v a. Effect a -> Widget v a

affAction :: forall v a. v -> Aff a -> Widget v a

asyncAction :: forall a v. v -> ((Either Error a -> Effect Unit) -> Effect (Effect Unit)) -> Widget v a

withViewEvent :: forall v a. ((a -> Effect Unit) -> v) -> Widget v a

Construct a widget from a primitive view event

wrapViewEvent :: forall v a. ((a -> Effect Unit) -> v -> v) -> Widget v a -> Widget v a

Construct a widget, by wrapping an existing widget in a view event

mkLeafWidget :: forall v a. ((a -> Effect Unit) -> v) -> Widget v a

Construct a widget with just props

loopState :: forall s a m. Monad m => s -> (s -> m (Either s a)) -> m a

A very useful combinator for widgets with localised state

tea :: forall x m s a. Monad m => s -> (s -> m a) -> (a -> s -> s) -> m x

The Elm Architecture