b8a82f1 · patch · git.iko.soy

git.iko.soy/patch

on develop help sign in

Haddocks for factorDyn and Adjustable

b8a82f1Ali Abrar8 years ago

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

compare with develop

unifiedsplit

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

11#ifdef USE_REFLEX_OPTIMIZER

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

13#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.

14module Reflex.Adjustable.Class

21module Reflex.Adjustable.Class

15 (

22 (

16 -- * The Adjustable typeclass

23 -- * The Adjustable typeclass

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

94 r <- ask

101 r <- ask

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

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

103

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)

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

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

98sequenceDMapWithAdjust = traverseDMapWithKeyWithAdjust $ \_ -> fmap Identity

111sequenceDMapWithAdjust = traverseDMapWithKeyWithAdjust $ \_ -> fmap Identity

112

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)

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

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

101sequenceDMapWithAdjustWithMove = traverseDMapWithKeyWithAdjustWithMove $ \_ -> fmap Identity

120sequenceDMapWithAdjustWithMove = traverseDMapWithKeyWithAdjustWithMove $ \_ -> fmap Identity

102

121

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)

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'))

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

104mapMapWithAdjustWithMove f m0 m' = do

130mapMapWithAdjustWithMove f m0 m' = do

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

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

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

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

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

110--------------------------------------------------------------------------------

136--------------------------------------------------------------------------------

111

137

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

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

139+-- | Synonym for 'Adjustable'

113type MonadAdjust = Adjustable

140type MonadAdjust = Adjustable

src/Reflex/Dynamic.hs+6

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

301 Left _ -> Nothing

302 Right a -> Just a

303

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').

304eitherDyn :: 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)))

306eitherDyn :: 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)))

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

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

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

308 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

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

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

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

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

310

312

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.

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

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

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

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

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

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

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

322 inner' <- filterEventKey k (updated d)

327 inner' <- filterEventKey k (updated d)

323 inner <- holdDyn v inner'

328 inner <- holdDyn v inner'

324 return $ k :=> Compose inner

329 return $ k :=> Compose inner

330+

325--------------------------------------------------------------------------------

331--------------------------------------------------------------------------------

326-- Demux

332-- Demux

327--------------------------------------------------------------------------------

333--------------------------------------------------------------------------------

src/Reflex/DynamicWriter/Class.hs+1

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

17import Reflex.Class (Dynamic)

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

20+-- | Type synonym for 'DynamicWriter'

20type MonadDynamicWriter = DynamicWriter

21type MonadDynamicWriter = DynamicWriter

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

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