b8a82f1 · reflex · git.iko.soy

git.iko.soy/reflex

Haddocks for factorDyn and Adjustable

commitb8a82f1c0f12e679cfd20d5aa0c310266278a438 authorAli Abrar <aliabrar@gmail.com> dateThu 28 Mar 2019, 16:13 (8 years ago) parent0c9b505

3 files changed+37−3

compare with develop

unifiedsplit

src/Reflex/Adjustable/Class.hs+30−3 src/Reflex/Dynamic.hs+6 src/Reflex/DynamicWriter/Class.hs+1

src/Reflex/Adjustable/Class.hs+30−3

@@ -11,6 +11,13 @@

1111#ifdef USE_REFLEX_OPTIMIZER

1212{-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-}

1313#endif

14+-- |

15+-- Module:

16+-- Reflex.Adjustable.Class

17+-- Description:

18+-- A class for actions that can be "adjusted" over time based on some 'Event'

19+-- such that, when observed after the firing of any such 'Event', the result

20+-- is as though the action was originally run with the 'Event's value.

1421module Reflex.Adjustable.Class

1522 (

1623 -- * The Adjustable typeclass

@@ -94,13 +101,32 @@ instance Adjustable t m => Adjustable t (ReaderT r m) where

94101 r <- ask

95102 lift $ traverseDMapWithKeyWithAdjustWithMove (\k v -> runReaderT (f k v) r) dm0 dm'

96103

97−sequenceDMapWithAdjust :: (GCompare k, Adjustable t m) => DMap k m -> Event t (PatchDMap k m) -> m (DMap k Identity, Event t (PatchDMap k Identity))

104+-- | Traverse a 'DMap' of 'Adjustable' actions, running each of them. The provided 'Event' of patches

105+-- to the 'DMap' can add, remove, or update values.

106+sequenceDMapWithAdjust

107+ :: (GCompare k, Adjustable t m)

108+ => DMap k m

109+ -> Event t (PatchDMap k m)

110+ -> m (DMap k Identity, Event t (PatchDMap k Identity))

98111sequenceDMapWithAdjust = traverseDMapWithKeyWithAdjust $ \_ -> fmap Identity

99112

100−sequenceDMapWithAdjustWithMove :: (GCompare k, Adjustable t m) => DMap k m -> Event t (PatchDMapWithMove k m) -> m (DMap k Identity, Event t (PatchDMapWithMove k Identity))

113+-- | Traverses a 'DMap' of 'Adjustable' actions, running each of them. The provided 'Event' of patches

114+-- to the 'DMap' can add, remove, update, move, or swap values.

115+sequenceDMapWithAdjustWithMove

116+ :: (GCompare k, Adjustable t m)

117+ => DMap k m

118+ -> Event t (PatchDMapWithMove k m)

119+ -> m (DMap k Identity, Event t (PatchDMapWithMove k Identity))

101120sequenceDMapWithAdjustWithMove = traverseDMapWithKeyWithAdjustWithMove $ \_ -> fmap Identity

102121

103−mapMapWithAdjustWithMove :: forall t m k v v'. (Adjustable t m, Ord k) => (k -> v -> m v') -> Map k v -> Event t (PatchMapWithMove k v) -> m (Map k v', Event t (PatchMapWithMove k v'))

122+-- | Traverses a 'Map', running the provided 'Adjustable' action. The provided 'Event' of patches to the 'Map'

123+-- can add, remove, update, move, or swap values.

124+mapMapWithAdjustWithMove

125+ :: forall t m k v v'. (Adjustable t m, Ord k)

126+ => (k -> v -> m v')

127+ -> Map k v

128+ -> Event t (PatchMapWithMove k v)

129+ -> m (Map k v', Event t (PatchMapWithMove k v'))

104130mapMapWithAdjustWithMove f m0 m' = do

105131 (out0 :: DMap (Const2 k v) (Constant v'), out') <- traverseDMapWithKeyWithAdjustWithMove (\(Const2 k) (Identity v) -> Constant <$> f k v) (mapToDMap m0) (const2PatchDMapWithMoveWith Identity <$> m')

106132 return (dmapToMapWith (\(Constant v') -> v') out0, patchDMapWithMoveToPatchMapWithMoveWith (\(Constant v') -> v') <$> out')

@@ -110,4 +136,5 @@ mapMapWithAdjustWithMove f m0 m' = do

110136--------------------------------------------------------------------------------

111137

112138{-# DEPRECATED MonadAdjust "Use Adjustable instead" #-}

139+-- | Synonym for 'Adjustable'

113140type MonadAdjust = Adjustable

src/Reflex/Dynamic.hs+6

@@ -301,6 +301,8 @@ maybeDyn = fmap (fmap unpack) . eitherDyn . fmap pack

301301 Left _ -> Nothing

302302 Right a -> Just a

303303

304+-- | Turns a 'Dynamic t (Either a b)' into a 'Dynamic t (Either (Dynamic t a) (Dynamic t b))' such that

305+-- the outer 'Dynamic' is updated only when the 'Either' constructor changes (e.g., from 'Left' to 'Right').

304306eitherDyn :: forall t a b m. (Reflex t, MonadFix m, MonadHold t m) => Dynamic t (Either a b) -> m (Dynamic t (Either (Dynamic t a) (Dynamic t b)))

305307eitherDyn = fmap (fmap unpack) . factorDyn . fmap eitherToDSum

306308 where unpack :: DSum (EitherTag a b) (Compose (Dynamic t) Identity) -> Either (Dynamic t a) (Dynamic t b)

@@ -308,6 +310,9 @@ eitherDyn = fmap (fmap unpack) . factorDyn . fmap eitherToDSum

308310 LeftTag :=> Compose a -> Left $ coerceDynamic a

309311 RightTag :=> Compose b -> Right $ coerceDynamic b

310312

313+-- | Factor a 'Dynamic t DSum' into a 'Dynamic' 'DSum' containing nested 'Dynamic' values.

314+-- The outer 'Dynamic' updates only when the key of the 'DSum' changes, while the update of the inner

315+-- 'Dynamic' represents updates within the current key.

311316factorDyn :: forall t m k v. (Reflex t, MonadHold t m, GEq k)

312317 => Dynamic t (DSum k v) -> m (Dynamic t (DSum k (Compose (Dynamic t) v)))

313318factorDyn d = buildDynamic (sample (current d) >>= holdKey) update where

@@ -322,6 +327,7 @@ factorDyn d = buildDynamic (sample (current d) >>= holdKey) update where

322327 inner' <- filterEventKey k (updated d)

323328 inner <- holdDyn v inner'

324329 return $ k :=> Compose inner

330+

325331--------------------------------------------------------------------------------

326332-- Demux

327333--------------------------------------------------------------------------------

src/Reflex/DynamicWriter/Class.hs+1

@@ -17,6 +17,7 @@ import Control.Monad.Reader (ReaderT, lift)

1717import Reflex.Class (Dynamic)

1818

1919{-# DEPRECATED MonadDynamicWriter "Use 'DynamicWriter' instead" #-}

20+-- | Type synonym for 'DynamicWriter'

2021type MonadDynamicWriter = DynamicWriter

2122

2223-- | 'MonadDynamicWriter' efficiently collects 'Dynamic' values using 'tellDyn'