Glazier.Strict

Documentation

newtype Gadget s m a c

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

Constructors

Gadget

Fields

• runGadget :: ReaderT a (StateT s m) c

Instances

Monad m => MonadState s (Gadget s m a)

Methods

get :: Gadget s m a s

put :: s -> Gadget s m a ()

state :: (s -> (a, s)) -> Gadget s m a a

Monad m => MonadReader a (Gadget s m a)

Methods

ask :: Gadget s m a a

local :: (a -> a) -> Gadget s m a a -> Gadget s m a a

reader :: (a -> a) -> Gadget s m a a

Monad m => Category * (Gadget s m)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Monad m => Arrow (Gadget s m)

Methods

arr :: (b -> c) -> Gadget s m b c

first :: Gadget s m b c -> Gadget s m (b, d) (c, d)

second :: Gadget s m b c -> Gadget s m (d, b) (d, c)

(***) :: Gadget s m b c -> Gadget s m b' c' -> Gadget s m (b, b') (c, c')

(&&&) :: Gadget s m b c -> Gadget s m b c' -> Gadget s m b (c, c')

MonadPlus m => ArrowZero (Gadget s m)

Methods

zeroArrow :: Gadget s m b c

MonadPlus m => ArrowPlus (Gadget s m)

Methods

(<+>) :: Gadget s m b c -> Gadget s m b c -> Gadget s m b c

Monad m => ArrowChoice (Gadget s m)

Methods

left :: Gadget s m b c -> Gadget s m (Either b d) (Either c d)

right :: Gadget s m b c -> Gadget s m (Either d b) (Either d c)

(+++) :: Gadget s m b c -> Gadget s m b' c' -> Gadget s m (Either b b') (Either c c')

(|||) :: Gadget s m b d -> Gadget s m c d -> Gadget s m (Either b c) d

Monad m => ArrowApply (Gadget s m)

Methods

app :: Gadget s m (Gadget s m b c, b) c

Monad m => Profunctor (Gadget s m)

Methods

dimap :: (a -> b) -> (c -> d) -> Gadget s m b c -> Gadget s m a d

lmap :: (a -> b) -> Gadget s m b c -> Gadget s m a c

rmap :: (b -> c) -> Gadget s m a b -> Gadget s m a c

(#.) :: Coercible * c b => (b -> c) -> Gadget s m a b -> Gadget s m a c

(.#) :: Coercible * b a => Gadget s m b c -> (a -> b) -> Gadget s m a c

Monad m => Choice (Gadget s m)

Methods

left' :: Gadget s m a b -> Gadget s m (Either a c) (Either b c)

right' :: Gadget s m a b -> Gadget s m (Either c a) (Either c b)

Monad m => Strong (Gadget s m)

Methods

first' :: Gadget s m a b -> Gadget s m (a, c) (b, c)

second' :: Gadget s m a b -> Gadget s m (c, a) (c, b)

Monad m => Monad (Gadget s m a)

Methods

(>>=) :: Gadget s m a a -> (a -> Gadget s m a b) -> Gadget s m a b

(>>) :: Gadget s m a a -> Gadget s m a b -> Gadget s m a b

return :: a -> Gadget s m a a

fail :: String -> Gadget s m a a

Functor m => Functor (Gadget s m a)

Methods

fmap :: (a -> b) -> Gadget s m a a -> Gadget s m a b

(<$) :: a -> Gadget s m a b -> Gadget s m a a

MonadFix m => MonadFix (Gadget s m a)

Methods

mfix :: (a -> Gadget s m a a) -> Gadget s m a a

MonadFail m => MonadFail (Gadget s m a)

Methods

fail :: String -> Gadget s m a a

Monad m => Applicative (Gadget s m a)

Methods

pure :: a -> Gadget s m a a

(<*>) :: Gadget s m a (a -> b) -> Gadget s m a a -> Gadget s m a b

(*>) :: Gadget s m a a -> Gadget s m a b -> Gadget s m a b

(<*) :: Gadget s m a a -> Gadget s m a b -> Gadget s m a a

MonadIO m => MonadIO (Gadget s m a)

Methods

liftIO :: IO a -> Gadget s m a a

MonadPlus m => Alternative (Gadget s m a)

Methods

empty :: Gadget s m a a

(<|>) :: Gadget s m a a -> Gadget s m a a -> Gadget s m a a

some :: Gadget s m a a -> Gadget s m a [a]

many :: Gadget s m a a -> Gadget s m a [a]

MonadPlus m => MonadPlus (Gadget s m a)

Methods

mzero :: Gadget s m a a

mplus :: Gadget s m a a -> Gadget s m a a -> Gadget s m a a

Monad m => Zoom (Gadget s m a) (Gadget t m a) s t

Methods

zoom :: LensLike' (Zoomed (Gadget s m a) c) t s -> Gadget s m a c -> Gadget t m a c

Monad m => Magnify (Gadget s m a) (Gadget s m b) a b

Methods

magnify :: LensLike' (Magnified (Gadget s m a) c) b a -> Gadget s m a c -> Gadget s m b c

(Monad m, Semigroup c) => Semigroup (Gadget s m a c)

Methods

(<>) :: Gadget s m a c -> Gadget s m a c -> Gadget s m a c

sconcat :: NonEmpty (Gadget s m a c) -> Gadget s m a c

stimes :: Integral b => b -> Gadget s m a c -> Gadget s m a c

(Monad m, Monoid c) => Monoid (Gadget s m a c)

Methods

mempty :: Gadget s m a c

mappend :: Gadget s m a c -> Gadget s m a c -> Gadget s m a c

mconcat :: [Gadget s m a c] -> Gadget s m a c

Wrapped (Gadget s0 m0 a0 c0)

Associated Types

type Unwrapped (Gadget s0 m0 a0 c0) :: *

Methods

_Wrapped' :: Iso' (Gadget s0 m0 a0 c0) (Unwrapped (Gadget s0 m0 a0 c0))

(~) * (Gadget s0 m0 a0 c0) t0 => Rewrapped (Gadget s1 m1 a1 c1) t0

Monad m => Dispatch (Gadget s m a c) (Gadget s m b c) a b

Methods

dispatch :: LensLike' (Dispatched (Gadget s m a c)) b a -> Gadget s m a c -> Gadget s m b c

Monad m => Implant (Gadget s m a c) (Gadget t m a c) s t

Methods

implant :: LensLike' (Implanted (Gadget s m a c)) t s -> Gadget s m a c -> Gadget t m a c

HasGadget (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0)

Methods

gadget :: Lens' (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0)

type Zoomed (Gadget s m a)

type Zoomed (Gadget s m a) = Zoomed (StateT s m)

type Magnified (Gadget s m a)

type Magnified (Gadget s m a) = Magnified (ReaderT * a (StateT s m))

type Unwrapped (Gadget s0 m0 a0 c0)

type Unwrapped (Gadget s0 m0 a0 c0) = ReaderT * a0 (StateT s0 m0) c0

type Dispatched (Gadget s m a c)

type Dispatched (Gadget s m a c) = Magnified (Gadget s m a) c

type Implanted (Gadget s m a c)

type Implanted (Gadget s m a c) = Zoomed (Gadget s m a) c

_Gadget :: Iso (Gadget s m a c) (Gadget s' m' a' c') (a -> s -> m (c, s)) (a' -> s' -> m' (c', s'))

This Iso 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 = _Gadget %~ 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 _Gadget %~ f

mkGadget' :: (a -> s -> m (c, s)) -> Gadget s m a c mkGadget' = review _Gadget

runGadget' :: Gadget s m a c -> (a -> s -> m (c, s)) runGadget' = view _Gadget

_Gadget' :: Iso' (Gadget s m a c) (a -> s -> m (c, s))

Non polymorphic version of _Gadget

hoistGadget :: Monad m => (forall b. m b -> n b) -> Gadget s m a c -> Gadget s n a c

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

A widget is basically a tuple with Gadget and Window.

Constructors

Widget

Fields

• widgetWindow :: Window m s v
• widgetGadget :: Gadget s m a c

Instances

(Monad m, Monoid v) => Category * (Widget s v m)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

(Monad m, Monoid v) => Arrow (Widget s v m)

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.

Methods

arr :: (b -> c) -> Widget s v m b c

first :: Widget s v m b c -> Widget s v m (b, d) (c, d)

second :: Widget s v m b c -> Widget s v m (d, b) (d, c)

(***) :: Widget s v m b c -> Widget s v m b' c' -> Widget s v m (b, b') (c, c')

(&&&) :: Widget s v m b c -> Widget s v m b c' -> Widget s v m b (c, c')

(Monad m, Monoid v) => ArrowChoice (Widget s v m)

Methods

left :: Widget s v m b c -> Widget s v m (Either b d) (Either c d)

right :: Widget s v m b c -> Widget s v m (Either d b) (Either d c)

(+++) :: Widget s v m b c -> Widget s v m b' c' -> Widget s v m (Either b b') (Either c c')

(|||) :: Widget s v m b d -> Widget s v m c d -> Widget s v m (Either b c) d

Monad m => Profunctor (Widget s v m)

Methods

dimap :: (a -> b) -> (c -> d) -> Widget s v m b c -> Widget s v m a d

lmap :: (a -> b) -> Widget s v m b c -> Widget s v m a c

rmap :: (b -> c) -> Widget s v m a b -> Widget s v m a c

(#.) :: Coercible * c b => (b -> c) -> Widget s v m a b -> Widget s v m a c

(.#) :: Coercible * b a => Widget s v m b c -> (a -> b) -> Widget s v m a c

Monad m => Choice (Widget s v m)

Methods

left' :: Widget s v m a b -> Widget s v m (Either a c) (Either b c)

right' :: Widget s v m a b -> Widget s v m (Either c a) (Either c b)

Monad m => Strong (Widget s v m)

Methods

first' :: Widget s v m a b -> Widget s v m (a, c) (b, c)

second' :: Widget s v m a b -> Widget s v m (c, a) (c, b)

Functor m => Functor (Widget s v m a)

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)

Methods

fmap :: (a -> b) -> Widget s v m a a -> Widget s v m a b

(<$) :: a -> Widget s v m a b -> Widget s v m a a

(Semigroup v, Monad m, Monoid v) => Applicative (Widget s v m a)

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

Methods

pure :: a -> Widget s v m a a

(<*>) :: Widget s v m a (a -> b) -> Widget s v m a a -> Widget s v m a b

(*>) :: Widget s v m a a -> Widget s v m a b -> Widget s v m a b

(<*) :: Widget s v m a a -> Widget s v m a b -> Widget s v m a a

(Monad m, Semigroup c, Semigroup v) => Semigroup (Widget s v m a c)

Methods

(<>) :: Widget s v m a c -> Widget s v m a c -> Widget s v m a c

sconcat :: NonEmpty (Widget s v m a c) -> Widget s v m a c

stimes :: Integral b => b -> Widget s v m a c -> Widget s v m a c

(Monad m, Monoid c, Monoid v) => Monoid (Widget s v m a c)

Methods

mempty :: Widget s v m a c

mappend :: Widget s v m a c -> Widget s v m a c -> Widget s v m a c

mconcat :: [Widget s v m a c] -> Widget s v m a c

HasWindow (Widget s0 v0 m0 a0 c0) (Window m0 s0 v0)

Methods

window :: Lens' (Widget s0 v0 m0 a0 c0) (Window m0 s0 v0)

HasGadget (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0)

Methods

gadget :: Lens' (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0)

Monad m => Dispatch (Widget s v m a c) (Widget s v m b c) a b

Methods

dispatch :: LensLike' (Dispatched (Widget s v m a c)) b a -> Widget s v m a c -> Widget s v m b c

Monad m => Implant (Widget s v m a c) (Widget t v m a c) s t

Methods

implant :: LensLike' (Implanted (Widget s v m a c)) t s -> Widget s v m a c -> Widget t v m a c

type Dispatched (Widget s v m a c)

type Dispatched (Widget s v m a c) = Dispatched (Gadget s m a c)

type Implanted (Widget s v m a c)

type Implanted (Widget s v m a c)

_Widget :: Iso (Widget s v m a c) (Widget s' v' m' a' c') (s -> m v, a -> s -> m (c, s)) (s' -> m' v', a' -> s' -> m' (c', s'))

This Iso gives the following functions: belowWidget :: ((s -> m v, a -> s -> m (c, s)) -> (s' -> m' v', a' -> s' -> m' (c', s'))) -> Widget s v m a c -> Widget s' v' m' a' c' belowWidget f = _Widget %~ f

aboveWidget :: (Widget s v m a c -> Widget s' v' m' a' c') -> (s -> m v, a -> s -> m (c, s)) -> (s' -> m' v', a' -> s' -> m' (c', s')) aboveWidget f = from _Widget %~ f

mkWidget' :: (s -> m v, a -> s -> m (c, s)) -> Widget s v m a c mkWidget' = review _Widget

runWidget' :: Widget s v m a c -> (s -> m v, a -> s -> m (c, s)) runWidget' = view _Widget

_Widget' :: Iso' (Widget s v m a c) (s -> m v, a -> s -> m (c, s))

Non polymorphic version of _Widget

_WrappingWidget :: Iso (Widget s v m a c) (Widget s' v' m' a' c') (Window m s v, Gadget s m a c) (Window m' s' v', Gadget s' m' a' c')

This Iso gives the following functions: underWidget :: ((Window m s v, Gadget s m a c) -> (Window m' s' v', Gadget s' m' a' c')) -> Widget s v m a c -> Widget s' v' m' a' c' underWidget f = _WrappingWidget %~ f

overWidget :: (Widget s v m a c -> Widget s' v' m' a' c') -> (Window m s v, Gadget s m a c) -> (Window m' s' v', Gadget s' m' a' c') overWidget f = from _WrappingWidget %~ f

mkWidget :: (Window m s v, Gadget s m a c) -> Widget s v m a c mkWidget = review _WrappingWidget

runWidget :: Widget s v m a c -> (Window m s v, Gadget s m a c) runWidget = view _WrappingWidget

_WrappingWidget' :: Iso' (Widget s v m a c) (Window m s v, Gadget s m a c)

Non polymorphic version of _WrappingWidget

hoistWidget :: Monad m => (forall x. m x -> n x) -> Widget s v m a c -> Widget s v n a c

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

class HasWindow s a | s -> a where

Minimal complete definition

window

Methods

window :: Lens' s a

Instances

HasWindow (Widget s0 v0 m0 a0 c0) (Window m0 s0 v0)

Methods

window :: Lens' (Widget s0 v0 m0 a0 c0) (Window m0 s0 v0)

class HasGadget s a | s -> a where

Minimal complete definition

gadget

Methods

gadget :: Lens' s a

Instances

HasGadget (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0)

Methods

gadget :: Lens' (Widget s0 v0 m0 a0 c0) (Gadget s0 m0 a0 c0)

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

Re-exports

module Glazier