Safe Haskell | None |
---|---|
Language | Haskell2010 |
- newtype Gadget s m a c = Gadget {}
- _GadgetT :: Iso (Gadget s m a c) (Gadget s' m' a' c') (a -> s -> m (c, s)) (a' -> s' -> m' (c', s'))
- _GadgetT' :: Iso' (Gadget s m a c) (a -> s -> m (c, s))
- hoistGadget :: Monad m => (forall b. m b -> n b) -> Gadget s m a c -> Gadget s n a c
- data Widget s v m a c = Widget {
- widgetWindow :: Window m s v
- widgetGadget :: Gadget s m a c
- hoistWidget :: Monad m => (forall x. m x -> n x) -> Widget s v m a c -> Widget s v n a c
- class HasWindow s a | s -> a where
- class HasGadget s a | s -> a where
- statically :: (Monad m, Monoid c) => Window m s v -> Widget s v m a c
- dynamically :: (Monad m, Monoid v) => Gadget s m a c -> Widget s v m a c
Documentation
newtype Gadget s m a c Source #
The Elm update function is a -> s -> (s, c)
This is isomorphic to ReaderT a (State s) c
ie, given an action "a", and a current state "s", return the new state "s"
and any commands "c" that need to be interpreted externally (eg. download file).
This is named Gadget instead of Update to avoid confusion with update from Data.Map
_GadgetT :: Iso (Gadget s m a c) (Gadget s' m' a' c') (a -> s -> m (c, s)) (a' -> s' -> m' (c', s')) Source #
This in conjuction with Wrapped instance gives the following functions: underGadget :: (ReaderT a (StateT s m) c -> ReaderT a' (StateT s' m') c') -> Gadget s m a c -> Gadget s' m' a' c' underGadget f = _Wrapping Gadget %~ f
overGadget :: (Gadget s m a c -> Gadget s' m' a' c') -> ReaderT a (StateT s m) c -> ReaderT a' (StateT s' m') c' overGadget f = _Unwrapping Gadget %~ f
belowGadget :: (a -> s -> m (c, s)) (a' -> s' -> m' (c', s')) -> Gadget s m a c -> Gadget s' m' a' c' belowGadget f = _GadgetT %~ f
aboveGadget :: (Gadget s m a c -> Gadget s' m' a' c') -> (a -> s -> m (c, s)) (a' -> s' -> m' (c', s')) aboveGadget f = from _GadgetT %~ f
hoistGadget :: Monad m => (forall b. m b -> n b) -> Gadget s m a c -> Gadget s n a c Source #
NB lift can be simulated: liftGadget :: (MonadTrans t, Monad m) => Gadget s m a c -> Gadget s (t m) a c liftGadget = _Wrapping Gadget %~ hoist (hoist lift)
data Widget s v m a c Source #
A widget is basically a tuple with Gadget and Window.
Widget | |
|
(Monad m, Monoid v) => Category * (Widget s v m) Source # | |
(Monad m, Monoid v) => Arrow (Widget s v m) Source # | No monad instance for Widget is possible, however an arrow is possible. The Arrow instance monoidally appends the Window, and uses the inner Gadget Arrow instance. |
(Monad m, Monoid v) => ArrowChoice (Widget s v m) Source # | |
Monad m => Profunctor (Widget s v m) Source # | |
Monad m => Choice (Widget s v m) Source # | |
Monad m => Strong (Widget s v m) Source # | |
Functor m => Functor (Widget s v m a) Source # | Widget Functor is lawful 1: fmap id = id (Widget w g) = Widget w (id $ g) = Widget w g 2: fmap (f . g) = fmap f . fmap g (Widget w gad) = Widget w ((f . g) $ gad) = Widget w ((fmap f . fmap g) gad) |
(Semigroup v, Monad m, Monoid v) => Applicative (Widget s v m a) Source # | Widget Applicative is lawful Identity: pure id * v = v Widget mempty (pure id) * Widget vw vg = Widget (mempty <> vw) (pure id * vg) = Widget vw vg Composition: pure (.) * u * v * w = u * (v * w) Widget mempty (pure (.)) * Widget uw ug * Widget vw vg * Widget ww wg = = Widget (mempty <> uw <> vw <> ww) (pure (.) * ug * vg * wg = Widget (uw <> vw <> ww) (ug * (vg * wg)) = Widget (uw <> (vw <> ww)) (ug * (vg * wg)) = Widget uw ug * (Widget vw vg * Widget ww wg) Interchange: u * pure y = pure ($ y) * u Widget uw ug * Widget mempty (pure y) = Widget (uw <> mempty) (ug * pure y) = Widget (mempty <> uw) (pure ($ y) * ug) = Widget mempty (pure $y) * Widget uw ug |
(Monad m, Semigroup c, Semigroup v) => Semigroup (Widget s v m a c) Source # | |
(Monad m, Monoid c, Monoid v) => Monoid (Widget s v m a c) Source # | |
HasWindow (Widget s0 v0 m0 a0 c0) (Window m0 s0 v0) Source # | |
HasGadget (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0) Source # | |
Monad m => Dispatch (Widget s v m a c) (Widget s v m b c) a b Source # | |
Monad m => Implant (Widget s v m a c) (Widget t v m a c) s t Source # | |
type Dispatched (Widget s v m a c) Source # | |
type Implanted (Widget s v m a c) Source # | |
hoistWidget :: Monad m => (forall x. m x -> n x) -> Widget s v m a c -> Widget s v n a c Source #
NB lift can be simulated: liftWidget :: (MonadTrans t, Monad m) => Widget s v m a c -> Widget s v (t m) a c liftWidget = hoistWidget lift