d349bfa · reflex · git.iko.soy

src/Reflex/Class.hs+11−3

compare with develop

unifiedsplit

@@ -103,6 +103,7 @@ module Reflex.Class

103 -- * Miscellaneous convenience functions

104 , ffor

105 , MonadAdjust (..)

106+ , runWithReplace

106 , sequenceDMapWithAdjust

107 , sequenceDMapWithAdjust

107 , sequenceDMapWithAdjustWithMove

108 , sequenceDMapWithAdjustWithMove

108 , mapMapWithAdjustWithMove

109 , mapMapWithAdjustWithMove

@@ -701,6 +702,8 @@ mergeWith = mergeWith' id

701

702

702{-# INLINE mergeWith' #-}

703{-# INLINE mergeWith' #-}

703mergeWith' :: Reflex t => (a -> b) -> (b -> b -> b) -> [Event t a] -> Event t b

704mergeWith' :: Reflex t => (a -> b) -> (b -> b -> b) -> [Event t a] -> Event t b

705+mergeWith' _ _ [] = never

706+mergeWith' f _ [e] = fmap f e

704mergeWith' f g es = fmap (Prelude.foldl1 g . map (\(Const2 _ :=> Identity v) -> f v) . DMap.toList)

707mergeWith' f g es = fmap (Prelude.foldl1 g . map (\(Const2 _ :=> Identity v) -> f v) . DMap.toList)

705 . merge

708 . merge

706 . DMap.fromDistinctAscList

709 . DMap.fromDistinctAscList

@@ -1023,6 +1026,9 @@ infixl 4 <@>

1023(<@) = tag

1026(<@) = tag

1024infixl 4 <@

1027infixl 4 <@

1025

1028

1029+runWithReplace :: MonadAdjust t m => m a -> Event t (m b) -> m (a, Event t b)

1030+runWithReplace = mapMWithReplace id id

1031+

1026-- | A 'Monad' that supports adjustment over time. After an action has been

1032-- | A 'Monad' that supports adjustment over time. After an action has been

1027-- run, if the given events fire, it will adjust itself so that its net effect

1033-- run, if the given events fire, it will adjust itself so that its net effect

1028-- is as though it had originally been run with the new value. Note that there

1034-- is as though it had originally been run with the new value. Note that there

@@ -1030,14 +1036,14 @@ infixl 4 <@

1030-- other side-effects) cannot be undone, so it is up to the instance implementer

1036-- other side-effects) cannot be undone, so it is up to the instance implementer

1031-- to determine what the best meaning for this class is in such cases.

1037-- to determine what the best meaning for this class is in such cases.

1032class (Reflex t, Monad m) => MonadAdjust t m | m -> t where

1038class (Reflex t, Monad m) => MonadAdjust t m | m -> t where

1033− runWithReplace :: m a -> Event t (m b) -> m (a, Event t b)

1039+ mapMWithReplace :: (a -> m b) -> (a' -> m b') -> a -> Event t a' -> m (b, Event t b')

1034 traverseDMapWithKeyWithAdjust :: GCompare k => (forall a. k a -> v a -> m (v' a)) -> DMap k v -> Event t (PatchDMap k v) -> m (DMap k v', Event t (PatchDMap k v'))

1040 traverseDMapWithKeyWithAdjust :: GCompare k => (forall a. k a -> v a -> m (v' a)) -> DMap k v -> Event t (PatchDMap k v) -> m (DMap k v', Event t (PatchDMap k v'))

1035 traverseDMapWithKeyWithAdjustWithMove :: GCompare k => (forall a. k a -> v a -> m (v' a)) -> DMap k v -> Event t (PatchDMapWithMove k v) -> m (DMap k v', Event t (PatchDMapWithMove k v'))

1041 traverseDMapWithKeyWithAdjustWithMove :: GCompare k => (forall a. k a -> v a -> m (v' a)) -> DMap k v -> Event t (PatchDMapWithMove k v) -> m (DMap k v', Event t (PatchDMapWithMove k v'))

1036

1042

1037instance MonadAdjust t m => MonadAdjust t (ReaderT r m) where

1043instance MonadAdjust t m => MonadAdjust t (ReaderT r m) where

1038− runWithReplace a0 a' = do

1044+ mapMWithReplace f g a0 a' = do

1039 r <- ask

1045 r <- ask

1040− lift $ runWithReplace (runReaderT a0 r) $ fmap (`runReaderT` r) a'

1046+ lift $ mapMWithReplace ((`runReaderT` r) . f) ((`runReaderT` r) . g) a0 a'

1041 traverseDMapWithKeyWithAdjust f dm0 dm' = do

1047 traverseDMapWithKeyWithAdjust f dm0 dm' = do

1042 r <- ask

1048 r <- ask

1043 lift $ traverseDMapWithKeyWithAdjust (\k v -> runReaderT (f k v) r) dm0 dm'

1049 lift $ traverseDMapWithKeyWithAdjust (\k v -> runReaderT (f k v) r) dm0 dm'

@@ -1094,6 +1100,8 @@ mergeWithCheap' f g = mergeWithFoldCheap' $ foldl1 g . fmap f

1094

1100

1095{-# INLINE mergeWithFoldCheap' #-}

1101{-# INLINE mergeWithFoldCheap' #-}

1096mergeWithFoldCheap' :: Reflex t => (NonEmpty a -> b) -> [Event t a] -> Event t b

1102mergeWithFoldCheap' :: Reflex t => (NonEmpty a -> b) -> [Event t a] -> Event t b

1103+mergeWithFoldCheap' _ [] = never

1104+mergeWithFoldCheap' f [e] = fmapCheap (f . (:|[])) e

1097mergeWithFoldCheap' f es =

1105mergeWithFoldCheap' f es =

1098 fmapCheap (f . (\(h : t) -> h :| t) . map (\(Const2 _ :=> Identity v) -> v) . DMap.toList)

1106 fmapCheap (f . (\(h : t) -> h :| t) . map (\(Const2 _ :=> Identity v) -> v) . DMap.toList)

1099 . merge

1107 . merge

src/Reflex/DynamicWriter.hs+2−2

@@ -138,8 +138,8 @@ newtype DynamicWriterTLoweredResult t w v a = DynamicWriterTLoweredResult (v a,

138-- 'MonadAdjust', the 'Dynamic' output of that action will also be updated to

139-- match.

140instance (MonadAdjust t m, MonadFix m, Monoid w, MonadHold t m, Reflex t) => MonadAdjust t (DynamicWriterT t w m) where

141− runWithReplace a0 a' = do

141+ mapMWithReplace f g a0 a' = do

142− (result0, result') <- lift $ runWithReplace (runDynamicWriterT a0) $ runDynamicWriterT <$> a'

142+ (result0, result') <- lift $ mapMWithReplace (runDynamicWriterT . f) (runDynamicWriterT . g) a0 a'

143 tellDyn . join =<< holdDyn (snd result0) (snd <$> result')

144 return (fst result0, fst <$> result')

145 traverseDMapWithKeyWithAdjust = traverseDMapWithKeyWithAdjustImpl traverseDMapWithKeyWithAdjust mapPatchDMap weakenPatchDMapWith mergeDynIncremental

src/Reflex/EventWriter.hs+21−13

@@ -17,7 +17,7 @@ module Reflex.EventWriter

17 ( EventWriterT (..)

18 , runEventWriterT

19 , EventWriter (..)

20− , runWithReplaceEventWriterTWith

20+ , mapMWithReplaceEventWriterTWith

21 , sequenceDMapWithAdjustEventWriterTWith

22 ) where

23

@@ -78,7 +78,7 @@ instance MonadHold t m => MonadHold t (EventWriterT t w m) where

78 holdIncremental v0 = lift . holdIncremental v0

79

80instance (Reflex t, MonadAdjust t m, MonadHold t m, Semigroup w, Semigroup w) => MonadAdjust t (EventWriterT t w m) where

81− runWithReplace = runWithReplaceEventWriterTWith $ \dm0 dm' -> lift $ runWithReplace dm0 dm'

81+ mapMWithReplace = mapMWithReplaceEventWriterTWith $ \f g dm0 dm' -> lift $ mapMWithReplace f g dm0 dm'

82 traverseDMapWithKeyWithAdjust = sequenceDMapWithAdjustEventWriterTWith (\f dm0 dm' -> lift $ traverseDMapWithKeyWithAdjust f dm0 dm') mapPatchDMap weakenPatchDMapWith patchMapNewElements mergeMapIncremental

83 traverseDMapWithKeyWithAdjustWithMove = sequenceDMapWithAdjustEventWriterTWith (\f dm0 dm' -> lift $ traverseDMapWithKeyWithAdjustWithMove f dm0 dm') mapPatchDMapWithMove weakenPatchDMapWithMoveWith patchMapWithMoveNewElements mergeMapIncrementalWithMove

84

@@ -88,19 +88,27 @@ instance Requester t m => Requester t (EventWriterT t w m) where

88 withRequesting f = EventWriterT $ withRequesting $ unEventWriterT . f

89

90

91−-- | Given a function like 'runWithReplace' for the underlying monad, implement

91+-- | Given a function like 'mapMWithReplace' for the underlying monad, implement

92−-- 'runWithReplace' for 'EventWriterT'. This is necessary when the underlying

92+-- 'mapMWithReplace' for 'EventWriterT'. This is necessary when the underlying

93-- monad doesn't have a 'MonadAdjust' instance or to override the default

94-- 'MonadAdjust' behavior.

95−runWithReplaceEventWriterTWith :: forall m t w a b. (Reflex t, MonadHold t m, Semigroup w)

95+mapMWithReplaceEventWriterTWith :: forall m t w a a' b b'. (Reflex t, MonadHold t m, Semigroup w)

96+ => (forall aa aa' bb bb'.

97+ (aa -> m bb) ->

98+ (aa' -> m bb') ->

99+ aa ->

100+ Event t aa' ->

96− => (forall a' b'. m a' -> Event t (m b') -> EventWriterT t w m (a', Event t b'))

101+ EventWriterT t w m (bb, Event t bb')

102+ )

97− -> EventWriterT t w m a

103+ -> (a -> EventWriterT t w m b)

98− -> Event t (EventWriterT t w m b)

104+ -> (a' -> EventWriterT t w m b')

105+ -> a

106+ -> Event t a'

99− -> EventWriterT t w m (a, Event t b)

107+ -> EventWriterT t w m (b, Event t b')

100−runWithReplaceEventWriterTWith f a0 a' = do

108+mapMWithReplaceEventWriterTWith base f g a0 a' = do

101− let g :: EventWriterT t w m c -> m (c, Seq (Event t w))

109+ let runInternal :: EventWriterT t w m c -> m (c, Seq (Event t w))

102− g (EventWriterT r) = runStateT r mempty

110+ runInternal (EventWriterT r) = runStateT r mempty

103− (result0, result') <- f (g a0) $ fmap g a'

111+ (result0, result') <- base (runInternal . f) (runInternal . g) a0 a'

104 request <- holdDyn (fmapCheap sconcat $ mergeList $ toList $ snd result0) $ fmapCheap (fmapCheap sconcat . mergeList . toList . snd) result'

112 request <- holdDyn (fmapCheap sconcat $ mergeList $ toList $ snd result0) $ fmapCheap (fmapCheap sconcat . mergeList . toList . snd) result'

105 -- We add these two separately to take advantage of the free merge being done later. The coincidence case must come first so that it has precedence if both fire simultaneously. (Really, we should probably block the 'switch' whenever 'updated' fires, but switchPromptlyDyn has the same issue.)

113 -- We add these two separately to take advantage of the free merge being done later. The coincidence case must come first so that it has precedence if both fire simultaneously. (Really, we should probably block the 'switch' whenever 'updated' fires, but switchPromptlyDyn has the same issue.)

106 EventWriterT $ modify $ flip (|>) $ coincidence $ updated request

114 EventWriterT $ modify $ flip (|>) $ coincidence $ updated request

src/Reflex/PerformEvent/Base.hs+5−5

@@ -70,11 +70,11 @@ instance (ReflexHost t, Ref m ~ Ref IO, PrimMonad (HostFrame t)) => PerformEvent

70 performEvent = PerformEventT . requestingIdentity

71

72instance (ReflexHost t, PrimMonad (HostFrame t)) => MonadAdjust t (PerformEventT t m) where

73− runWithReplace outerA0 outerA' = PerformEventT $ runWithReplaceRequesterTWith f (coerce outerA0) (coerceEvent outerA')

73+ mapMWithReplace f g outerA0 outerA' = PerformEventT $ mapMWithReplaceRequesterTWith base (coerce f) (coerce g) outerA0 outerA'

74− where f :: HostFrame t a -> Event t (HostFrame t b) -> RequesterT t (HostFrame t) Identity (HostFrame t) (a, Event t b)

74+ where base :: (a -> HostFrame t b) -> (a' -> HostFrame t b') -> a -> Event t a' -> RequesterT t (HostFrame t) Identity (HostFrame t) (b, Event t b')

75− f a0 a' = do

75+ base f' g' a0 a' = do

76− result0 <- lift a0

76+ result0 <- lift $ f' a0

77− result' <- requestingIdentity a'

77+ result' <- requestingIdentity $ fmapCheap g' a'

78 return (result0, result')

79 traverseDMapWithKeyWithAdjust f outerDm0 outerDm' = PerformEventT $ sequenceDMapWithAdjustRequesterTWith (defaultAdjustBase traversePatchDMapWithKey) mapPatchDMap weakenPatchDMapWith patchMapNewElements mergeMapIncremental (\k v -> unPerformEventT $ f k v) (coerce outerDm0) (coerceEvent outerDm')

80 traverseDMapWithKeyWithAdjustWithMove f outerDm0 outerDm' = PerformEventT $ sequenceDMapWithAdjustRequesterTWith (defaultAdjustBase traversePatchDMapWithMoveWithKey) mapPatchDMapWithMove weakenPatchDMapWithMoveWith patchMapWithMoveNewElements mergeMapIncrementalWithMove (\k v -> unPerformEventT $ f k v) (coerce outerDm0) (coerceEvent outerDm')

src/Reflex/PostBuild/Base.hs+5−5

@@ -73,11 +73,11 @@ instance MonadHold t m => MonadHold t (PostBuildT t m) where

73 holdIncremental v0 = lift . holdIncremental v0

74

75instance PerformEvent t m => PerformEvent t (PostBuildT t m) where

76− type Performable (PostBuildT t m) = PostBuildT t (Performable m)

76+ type Performable (PostBuildT t m) = Performable m

77 {-# INLINABLE performEvent_ #-}

78− performEvent_ e = liftWith $ \run -> performEvent_ $ fmap run e

78+ performEvent_ = lift . performEvent_

79 {-# INLINABLE performEvent #-}

80− performEvent e = liftWith $ \run -> performEvent $ fmap run e

80+ performEvent = lift . performEvent

81

82instance (ReflexHost t, MonadReflexCreateTrigger t m) => MonadReflexCreateTrigger t (PostBuildT t m) where

83 {-# INLINABLE newEventWithTrigger #-}

@@ -106,10 +106,10 @@ instance MonadAtomicRef m => MonadAtomicRef (PostBuildT t m) where

106 atomicModifyRef r = lift . atomicModifyRef r

107

108instance (Reflex t, MonadHold t m, MonadFix m, MonadAdjust t m, PerformEvent t m) => MonadAdjust t (PostBuildT t m) where

109− runWithReplace a0 a' = do

109+ mapMWithReplace f g a0 a' = do

110 postBuild <- getPostBuild

111 lift $ do

112− rec result@(_, result') <- runWithReplace (runPostBuildT a0 postBuild) $ fmap (\v -> runPostBuildT v =<< headE voidResult') a'

112+ rec result@(_, result') <- mapMWithReplace ((`runPostBuildT` postBuild) . f) (\v -> runPostBuildT (g v) =<< headE voidResult') a0 a'

113 let voidResult' = fmapCheap (\_ -> ()) result'

114 return result

115 traverseDMapWithKeyWithAdjust = mapDMapWithAdjustImpl traverseDMapWithKeyWithAdjust mapPatchDMap

src/Reflex/Query/Base.hs+2−2

@@ -71,8 +71,8 @@ let sampleBs :: forall m'. MonadSample t m' => [Behavior t q] -> m' q

71-}

72

73instance (Reflex t, MonadFix m, Group q, Additive q, Query q, MonadHold t m, MonadAdjust t m) => MonadAdjust t (QueryT t q m) where

74− runWithReplace (QueryT a0) a' = do

74+ mapMWithReplace f g a0 a' = do

75− ((r0, bs0), r') <- QueryT $ lift $ runWithReplace (runStateT a0 []) $ fmapCheap (flip runStateT [] . unQueryT) a'

75+ ((r0, bs0), r') <- QueryT $ lift $ mapMWithReplace ((`runStateT` []) . unQueryT . f) ((`runStateT` []) . unQueryT . g) a0 a'

76 let sampleBs :: forall m'. MonadSample t m' => [Behavior t q] -> m' q

77 sampleBs = foldlM (\b a -> (b <>) <$> sample a) mempty

78 bs' = fmapCheap snd $ r'

src/Reflex/Requester/Base.hs+25−14

@@ -17,7 +17,7 @@

17module Reflex.Requester.Base

18 ( RequesterT (..)

19 , runRequesterT

20− , runWithReplaceRequesterTWith

20+ , mapMWithReplaceRequesterTWith

21 , sequenceDMapWithAdjustRequesterTWith

22 ) where

23

@@ -105,23 +105,34 @@ instance MonadReader r m => MonadReader r (RequesterT t request response m) wher

105 reader = lift . reader

106

107instance (Reflex t, MonadAdjust t m, MonadHold t m) => MonadAdjust t (RequesterT t request response m) where

108− runWithReplace (RequesterT a) em = RequesterT $ runWithReplace a (coerceEvent em)

108+ mapMWithReplace f g a0 a' = RequesterT $ mapMWithReplace (coerce f) (coerce g) a0 a'

109 traverseDMapWithKeyWithAdjust f dm edm = RequesterT $ traverseDMapWithKeyWithAdjust (\k v -> unRequesterT $ f k v) (coerce dm) (coerceEvent edm)

110 traverseDMapWithKeyWithAdjustWithMove f dm edm = RequesterT $ traverseDMapWithKeyWithAdjustWithMove (\k v -> unRequesterT $ f k v) (coerce dm) (coerceEvent edm)

111

112−runWithReplaceRequesterTWith :: forall m t request response a b. (Reflex t, MonadHold t m)

112+mapMWithReplaceRequesterTWith :: forall m t request response a a' b b'. (Reflex t, MonadHold t m)

113+ => (forall aa aa' bb bb'.

114+ (aa -> m bb) ->

115+ (aa' -> m bb') ->

116+ aa ->

117+ Event t aa' ->

113− => (forall a' b'. m a' -> Event t (m b') -> RequesterT t request response m (a', Event t b'))

118+ RequesterT t request response m (bb, Event t bb')

119+ )

114− -> RequesterT t request response m a

120+ -> (a -> RequesterT t request response m b)

115− -> Event t (RequesterT t request response m b)

121+ -> (a' -> RequesterT t request response m b')

122+ -> a

123+ -> Event t a'

116− -> RequesterT t request response m (a, Event t b)

124+ -> RequesterT t request response m (b, Event t b')

117−runWithReplaceRequesterTWith f a0 a' =

125+mapMWithReplaceRequesterTWith base f g a0 a' =

126+ let base' :: forall aaa aaa' bbb bbb'.

118− let f' :: forall a' b'. ReaderT (EventSelector t (WrapArg response (Tag (PrimState m)))) m a'

127+ (aaa -> ReaderT (EventSelector t (WrapArg response (Tag (PrimState m)))) m bbb)

119− -> Event t (ReaderT (EventSelector t (WrapArg response (Tag (PrimState m)))) m b')

128+ -> (aaa' -> ReaderT (EventSelector t (WrapArg response (Tag (PrimState m)))) m bbb')

129+ -> aaa

130+ -> Event t aaa'

120− -> EventWriterT t (DMap (Tag (PrimState m)) request) (ReaderT (EventSelector t (WrapArg response (Tag (PrimState m)))) m) (a', Event t b')

131+ -> EventWriterT t (DMap (Tag (PrimState m)) request) (ReaderT (EventSelector t (WrapArg response (Tag (PrimState m)))) m) (bbb, Event t bbb')

121− f' x y = do

132+ base' f' g' x y = do

122 r <- EventWriterT $ ask

133 r <- EventWriterT $ ask

123− unRequesterT (f (runReaderT x r) (fmapCheap (`runReaderT` r) y))

134+ unRequesterT $ base ((`runReaderT` r) . f') ((`runReaderT` r) . g') x y

124− in RequesterT $ runWithReplaceEventWriterTWith f' (coerce a0) (coerceEvent a')

135+ in RequesterT $ mapMWithReplaceEventWriterTWith base' (coerce f) (coerce g) a0 a'

125

136

126sequenceDMapWithAdjustRequesterTWith :: forall k t request response m v v' p p'.

137sequenceDMapWithAdjustRequesterTWith :: forall k t request response m v v' p p'.

127 ( GCompare k

138 ( GCompare k

src/Reflex/Spider/Internal.hs+11−3

@@ -1113,16 +1113,24 @@ instance HasSpiderTimeline x => Align (Event x) where

1113 nil = eventNever

1114 align ea eb = fmapMaybe dmapToThese $ merge $ dynamicConst $ DMap.fromList [LeftTag :=> ea, RightTag :=> eb]

1115

1116+{-# INLINE mapEventCheap #-}

1117+mapEventCheap :: HasSpiderTimeline x => (a -> b) -> Event x a -> Event x b

1118+mapEventCheap f = pushCheap $ return . Just . f

1119+

1120+{-# INLINE alignCheap #-}

1121+alignCheap :: HasSpiderTimeline x => Event x a -> Event x b -> Event x (These a b)

1122+alignCheap ea eb = fmapMaybe dmapToThese $ mergeCheap $ dynamicConst $ DMap.fromList [LeftTag :=> ea, RightTag :=> eb]

1123+

1116newtype Dyn x p = Dyn { unDyn :: IORef (Either (BehaviorM x (PatchTarget p), Event x p) (Hold x p)) }

1124newtype Dyn x p = Dyn { unDyn :: IORef (Either (BehaviorM x (PatchTarget p), Event x p) (Hold x p)) }

1117

1125

1118newMapDyn :: HasSpiderTimeline x => (a -> b) -> Dynamic x (Identity a) -> Dynamic x (Identity b)

1126newMapDyn :: HasSpiderTimeline x => (a -> b) -> Dynamic x (Identity a) -> Dynamic x (Identity b)

1119−newMapDyn f d = dynamicDynIdentity $ unsafeBuildDynamic (fmap f $ readBehaviorTracked $ dynamicCurrent d) (Identity . f . runIdentity <$> dynamicUpdated d)

1127+newMapDyn f d = dynamicDynIdentity $ unsafeBuildDynamic (fmap f $ readBehaviorTracked $ dynamicCurrent d) (mapEventCheap (Identity . f . runIdentity) $ dynamicUpdated d)

1120

1128

1121--TODO: Avoid the duplication between this and R.zipDynWith

1129--TODO: Avoid the duplication between this and R.zipDynWith

1122zipDynWith :: HasSpiderTimeline x => (a -> b -> c) -> Dynamic x (Identity a) -> Dynamic x (Identity b) -> Dynamic x (Identity c)

1130zipDynWith :: HasSpiderTimeline x => (a -> b -> c) -> Dynamic x (Identity a) -> Dynamic x (Identity b) -> Dynamic x (Identity c)

1123zipDynWith f da db =

1131zipDynWith f da db =

1124− let eab = align (dynamicUpdated da) (dynamicUpdated db)

1132+ let eab = alignCheap (dynamicUpdated da) (dynamicUpdated db)

1125− ec = flip push eab $ \o -> do

1133+ ec = flip pushCheap eab $ \o -> do

1126 (a, b) <- case o of

1134 (a, b) <- case o of

1127 This (Identity a) -> do

1135 This (Identity a) -> do

1128 b <- readBehaviorUntracked $ dynamicCurrent db

1136 b <- readBehaviorUntracked $ dynamicCurrent db

src/Reflex/TriggerEvent/Base.hs+2−2

@@ -116,8 +116,8 @@ instance MonadHold t m => MonadHold t (TriggerEventT t m) where

116 holdIncremental v0 v' = lift $ holdIncremental v0 v'

117

118instance MonadAdjust t m => MonadAdjust t (TriggerEventT t m) where

119− {-# INLINABLE runWithReplace #-}

119+ {-# INLINABLE mapMWithReplace #-}

120− runWithReplace (TriggerEventT a0) a' = TriggerEventT $ runWithReplace a0 (coerceEvent a')

120+ mapMWithReplace f g a0 a' = TriggerEventT $ mapMWithReplace (unTriggerEventT . f) (unTriggerEventT . g) a0 a'

121 {-# INLINABLE traverseDMapWithKeyWithAdjust #-}

122 traverseDMapWithKeyWithAdjust f dm0 dm' = TriggerEventT $ traverseDMapWithKeyWithAdjust (coerce . f) dm0 dm'

123 {-# INLINABLE traverseDMapWithKeyWithAdjustWithMove #-}