Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell98 |
This is a more general, cleaner interface that allows Model to Model synchronization and view to view.
It is meant to replace Hails.MVC.Controller.Reactive as soon as we do not need to provide an undefined value for the function reactiveValueOnCanRead.
- class ReactiveValueRead a b m | a -> b where
- reactiveValueOnCanRead :: a -> m () -> m ()
- reactiveValueRead :: a -> m b
- class ReactiveValueWrite a b m where
- reactiveValueWrite :: a -> b -> m ()
- class (ReactiveValueRead a b m, ReactiveValueWrite a b m) => ReactiveValueReadWrite a b m
- (=:>) :: Monad m => (ReactiveValueRead a b m, ReactiveValueWrite c b m) => a -> c -> m ()
- (<:=) :: Monad m => (ReactiveValueRead a b m, ReactiveValueWrite c b m) => c -> a -> m ()
- (=:=) :: Monad m => (ReactiveValueReadWrite a b m, ReactiveValueReadWrite c b m) => a -> c -> m ()
- type FieldGetter m a = m a
- type FieldSetter m a = a -> m ()
- type FieldNotifier m a = m () -> m ()
- data ReactiveFieldRead m a = ReactiveFieldRead (FieldGetter m a) (FieldNotifier m a)
- data ReactiveFieldWrite m a = ReactiveFieldWrite (FieldSetter m a)
- data ReactiveFieldReadWrite m a = ReactiveFieldReadWrite (FieldSetter m a) (FieldGetter m a) (FieldNotifier m a)
- type ReactiveFieldActivatable m = ReactiveFieldRead m ()
- mkActivatable :: Monad m => (m () -> m ()) -> ReactiveFieldActivatable m
- class ReactiveValueActivatable m a where
- defaultActivation :: a -> ReactiveFieldActivatable m
- constR :: Monad m => a -> ReactiveFieldRead m a
- initRW :: Monad m => a -> ReactiveFieldRead m a
- liftR :: (Monad m, ReactiveValueRead a b m) => a -> (b -> c) -> ReactiveFieldRead m c
- liftR2 :: (Monad m, ReactiveValueRead a b m, ReactiveValueRead c d m) => a -> c -> (b -> d -> e) -> ReactiveFieldRead m e
- liftMR :: (Monad m, ReactiveValueRead a b m) => a -> (b -> m c) -> ReactiveFieldRead m c
- liftW :: (Monad m, ReactiveValueWrite a b m) => a -> (c -> b) -> ReactiveFieldWrite m c
- liftW2 :: (Monad m, ReactiveValueWrite a b m, ReactiveValueWrite d e m) => a -> d -> (c -> (b, e)) -> ReactiveFieldWrite m c
- liftMW :: (Monad m, ReactiveValueWrite a b m) => a -> (c -> m b) -> ReactiveFieldWrite m c
- readOnly :: ReactiveValueRead r a m => r -> ReactiveFieldRead m a
- writeOnly :: ReactiveValueWrite r a m => r -> ReactiveFieldWrite m a
- wrapMW :: (a -> m ()) -> ReactiveFieldWrite m a
- wrapDo :: m () -> ReactiveFieldWrite m a
- wrapDo_ :: m () -> ReactiveFieldWrite m ()
- wrapMR :: m a -> (m () -> m ()) -> ReactiveFieldRead m a
- wrapMRPassive :: Monad m => m a -> ReactiveFieldRead m a
- newtype BijectiveFunc a b = BijectiveFunc {
- unBijectiveFunc :: (a -> b, b -> a)
- bijection :: (a -> b, b -> a) -> BijectiveFunc a b
- direct :: BijectiveFunc a b -> a -> b
- inverse :: BijectiveFunc a b -> b -> a
- type Involution a = BijectiveFunc a a
- involution :: (a -> a) -> Involution a
- liftRW :: (Monad m, ReactiveValueReadWrite a b m) => a -> BijectiveFunc b c -> ReactiveFieldReadWrite m c
- liftRW2 :: (Monad m, ReactiveValueReadWrite a b m, ReactiveValueReadWrite c d m) => a -> c -> BijectiveFunc e (b, d) -> ReactiveFieldReadWrite m e
- pairRW :: (Monad m, ReactiveValueReadWrite a b m, ReactiveValueReadWrite c d m) => a -> c -> ReactiveFieldReadWrite m (b, d)
- eqCheck :: (Eq v, Monad m) => ReactiveFieldReadWrite m v -> ReactiveFieldReadWrite m v
- modRW :: (Monad m, ReactiveValueReadWrite a b m) => (b -> c -> b) -> a -> ReactiveFieldWrite m c
- reactiveValueModify :: (Monad m, ReactiveValueReadWrite a b m) => a -> (b -> b) -> m ()
- passivelyR :: (Monad m, ReactiveValueRead a b m) => a -> ReactiveFieldRead m b
- passivelyRW :: (Monad m, ReactiveValueReadWrite a b m) => a -> ReactiveFieldReadWrite m b
- ifRW_ :: (Monad m, ReactiveValueRead c Bool m, ReactiveValueReadWrite v a m) => c -> v -> ReactiveFieldReadWrite m a
- ifRW :: (Monad m, ReactiveValueRead c Bool m, ReactiveValueReadWrite v a m) => c -> v -> ReactiveFieldReadWrite m a
- guardRO :: (Monad m, ReactiveValueRead c Bool m) => c -> ReactiveFieldRead m Bool
- governingR :: (ReactiveValueRead a b m, ReactiveValueRead c d m) => a -> c -> ReactiveFieldRead m d
Reactive values: common interface
class ReactiveValueRead a b m | a -> b where Source
Readable reactive values
reactiveValueOnCanRead :: a -> m () -> m () Source
reactiveValueRead :: a -> m b Source
ReactiveValueRead (ReactiveFieldReadWrite m a) a m | |
ReactiveValueRead (ReactiveFieldRead m a) a m |
class ReactiveValueWrite a b m where Source
Writable reactive values
reactiveValueWrite :: a -> b -> m () Source
ReactiveValueWrite (ReactiveFieldReadWrite m a) a m | |
ReactiveValueWrite (ReactiveFieldWrite m a) a m |
class (ReactiveValueRead a b m, ReactiveValueWrite a b m) => ReactiveValueReadWrite a b m Source
Read-write reactive values
ReactiveValueReadWrite (ReactiveFieldReadWrite m a) a m |
Reactive rules (data dependency/passing building combinators)
(=:>) :: Monad m => (ReactiveValueRead a b m, ReactiveValueWrite c b m) => a -> c -> m () infix 9 Source
Priorities so that we can write them infix without parenthesising
Left to right
(<:=) :: Monad m => (ReactiveValueRead a b m, ReactiveValueWrite c b m) => c -> a -> m () infix 9 Source
Right-to-left
(=:=) :: Monad m => (ReactiveValueReadWrite a b m, ReactiveValueReadWrite c b m) => a -> c -> m () infix 9 Source
Bidirectional
Purely functional implementation
Setters, getters and notifiers
type FieldGetter m a = m a Source
type FieldSetter m a = a -> m () Source
type FieldNotifier m a = m () -> m () Source
Concrete types implementing the above interface
data ReactiveFieldRead m a Source
ReactiveFieldRead (FieldGetter m a) (FieldNotifier m a) |
(Functor m, Monad m) => Functor (ReactiveFieldRead m) | |
ReactiveValueRead (ReactiveFieldRead m a) a m |
data ReactiveFieldWrite m a Source
Monad m => Contravariant (ReactiveFieldWrite m) | |
ReactiveValueWrite (ReactiveFieldWrite m a) a m |
data ReactiveFieldReadWrite m a Source
ReactiveFieldReadWrite (FieldSetter m a) (FieldGetter m a) (FieldNotifier m a) |
Monad m => GFunctor (ReactiveFieldReadWrite m) BijectiveFunc | |
ReactiveValueReadWrite (ReactiveFieldReadWrite m a) a m | |
ReactiveValueWrite (ReactiveFieldReadWrite m a) a m | |
ReactiveValueRead (ReactiveFieldReadWrite m a) a m |
Activatable reactive values (producing units)
type ReactiveFieldActivatable m = ReactiveFieldRead m () Source
mkActivatable :: Monad m => (m () -> m ()) -> ReactiveFieldActivatable m Source
class ReactiveValueActivatable m a where Source
defaultActivation :: a -> ReactiveFieldActivatable m Source
Creating RVs based on other RVs
Lifting onto readable values
constR :: Monad m => a -> ReactiveFieldRead m a Source
initRW :: Monad m => a -> ReactiveFieldRead m a Source
Lifting onto readable values
liftR :: (Monad m, ReactiveValueRead a b m) => a -> (b -> c) -> ReactiveFieldRead m c Source
liftR2 :: (Monad m, ReactiveValueRead a b m, ReactiveValueRead c d m) => a -> c -> (b -> d -> e) -> ReactiveFieldRead m e Source
liftMR :: (Monad m, ReactiveValueRead a b m) => a -> (b -> m c) -> ReactiveFieldRead m c Source
Lifting onto writeable values
liftW :: (Monad m, ReactiveValueWrite a b m) => a -> (c -> b) -> ReactiveFieldWrite m c Source
liftW2 :: (Monad m, ReactiveValueWrite a b m, ReactiveValueWrite d e m) => a -> d -> (c -> (b, e)) -> ReactiveFieldWrite m c Source
liftMW :: (Monad m, ReactiveValueWrite a b m) => a -> (c -> m b) -> ReactiveFieldWrite m c Source
readOnly :: ReactiveValueRead r a m => r -> ReactiveFieldRead m a Source
writeOnly :: ReactiveValueWrite r a m => r -> ReactiveFieldWrite m a Source
Lift monadic operations
Lifting (sink) computations into writable RVs.
wrapMW :: (a -> m ()) -> ReactiveFieldWrite m a Source
Wrap a monadic computation in a writable reactive value.
wrapDo :: m () -> ReactiveFieldWrite m a Source
Wrap a monadic computation in a writable reactive value. It discards the written value and executes the operation.
Note: Because the value is discarded, the resulting RV is
polymorphic in the value that may be written to it. Using
wrapDo_
may save you some extra type signatures.
wrapDo_ :: m () -> ReactiveFieldWrite m () Source
Wrap a monadic computation in a writable reactive value of type unit. It discards the written value and executes the operation.
Lifting (source) computations into readable RVs.
wrapMR :: m a -> (m () -> m ()) -> ReactiveFieldRead m a Source
Wrap an reading operation and an notification installer in a readable reactive value.
wrapMRPassive :: Monad m => m a -> ReactiveFieldRead m a Source
Wrap an reading operation into an RV. Because there is no way to detect changes, the resulting RV is passive (does not push updates).
Lifting onto read-write values
Bijections
newtype BijectiveFunc a b Source
BijectiveFunc | |
|
Monad m => GFunctor (ReactiveFieldReadWrite m) BijectiveFunc |
bijection :: (a -> b, b -> a) -> BijectiveFunc a b Source
direct :: BijectiveFunc a b -> a -> b Source
inverse :: BijectiveFunc a b -> b -> a Source
type Involution a = BijectiveFunc a a Source
involution :: (a -> a) -> Involution a Source
Actual lifting
liftRW :: (Monad m, ReactiveValueReadWrite a b m) => a -> BijectiveFunc b c -> ReactiveFieldReadWrite m c Source
liftRW2 :: (Monad m, ReactiveValueReadWrite a b m, ReactiveValueReadWrite c d m) => a -> c -> BijectiveFunc e (b, d) -> ReactiveFieldReadWrite m e Source
pairRW :: (Monad m, ReactiveValueReadWrite a b m, ReactiveValueReadWrite c d m) => a -> c -> ReactiveFieldReadWrite m (b, d) Source
eqCheck :: (Eq v, Monad m) => ReactiveFieldReadWrite m v -> ReactiveFieldReadWrite m v Source
Modifying reactive values (applying modification transformations)
modRW :: (Monad m, ReactiveValueReadWrite a b m) => (b -> c -> b) -> a -> ReactiveFieldWrite m c Source
Lifting modification functions
reactiveValueModify :: (Monad m, ReactiveValueReadWrite a b m) => a -> (b -> b) -> m () Source
Deactivating reactive values
passivelyR :: (Monad m, ReactiveValueRead a b m) => a -> ReactiveFieldRead m b Source
Turning an active RV into a passive one (does not propagate changes) Note that this does not really affect the RV itself, only produces a new RV that will not propagate changes. So, if used in a reactive relation, values will not get propagated when they change. It is useful in combination with lifts, to achieve things similar to Yampa's tagging, but this might be more general.
passivelyRW :: (Monad m, ReactiveValueReadWrite a b m) => a -> ReactiveFieldReadWrite m b Source
Conditionals
ifRW_ :: (Monad m, ReactiveValueRead c Bool m, ReactiveValueReadWrite v a m) => c -> v -> ReactiveFieldReadWrite m a Source
ifRW :: (Monad m, ReactiveValueRead c Bool m, ReactiveValueReadWrite v a m) => c -> v -> ReactiveFieldReadWrite m a Source
guardRO :: (Monad m, ReactiveValueRead c Bool m) => c -> ReactiveFieldRead m Bool Source
Category theoretic definitions
governingR :: (ReactiveValueRead a b m, ReactiveValueRead c d m) => a -> c -> ReactiveFieldRead m d Source
Temporary: will be moved to Keera Hails' Reactive Values library.