1024703 · patch · git.iko.soy

git.iko.soy/patch

on develop help sign in

Fix deprecation warnings related to updated Data.Some

1024703Ali Abrar7 years ago

reflex.cabal+1−1

compare with develop

unifiedsplit

@@ -47,7 +47,7 @@ library

47 constraints-extras >= 0.2,

48 containers >= 0.5 && < 0.7,

49 data-default >= 0.5 && < 0.8,

50− dependent-map >= 0.2.4 && < 0.3,

50+ dependent-map >= 0.3 && < 0.4,

51 exception-transformers == 0.4.*,

52 lens >= 4.7 && < 5,

53 monad-control >= 1.0.1 && < 1.1,

src/Data/Functor/Misc.hs+2−3

@@ -52,8 +52,7 @@ import Data.IntMap (IntMap)

52import qualified Data.IntMap as IntMap

53import Data.Map (Map)

54import qualified Data.Map as Map

55−import Data.Some (Some)

55+import Data.Some (Some(Some))

56−import qualified Data.Some as Some

57import Data.These

56import Data.These

58import Data.Typeable hiding (Refl)

57import Data.Typeable hiding (Refl)

@@ -121,7 +120,7 @@ intMapWithFunctorToDMap = DMap.fromDistinctAscList . map (\(k, v) -> Const2 k :=

121-- | Convert a 'DMap' to a regular 'Map' by forgetting the types associated with

120-- | Convert a 'DMap' to a regular 'Map' by forgetting the types associated with

122-- the keys, using a function to remove the wrapping 'Functor'

121-- the keys, using a function to remove the wrapping 'Functor'

123weakenDMapWith :: (forall a. v a -> v') -> DMap k v -> Map (Some k) v'

122weakenDMapWith :: (forall a. v a -> v') -> DMap k v -> Map (Some k) v'

124−weakenDMapWith f = Map.fromDistinctAscList . map (\(k :=> v) -> (Some.This k, f v)) . DMap.toAscList

123+weakenDMapWith f = Map.fromDistinctAscList . map (\(k :=> v) -> (Some k, f v)) . DMap.toAscList

125

124

126--------------------------------------------------------------------------------

125--------------------------------------------------------------------------------

127-- WrapArg

126-- WrapArg

src/Reflex/Class.hs+3−4

@@ -193,8 +193,7 @@ import qualified Data.IntMap.Strict as IntMap

193import Data.List.NonEmpty (NonEmpty (..))

194import Data.Map (Map)

195import Data.Semigroup (Semigroup, sconcat, stimes, (<>))

196−import Data.Some (Some)

196+import Data.Some (Some(Some))

197−import qualified Data.Some as Some

198import Data.String

197import Data.String

199import Data.These

198import Data.These

200import Data.Type.Coercion

199import Data.Type.Coercion

@@ -1155,9 +1154,9 @@ factorEvent

1155 -> Event t (DSum k v)

1154 -> Event t (DSum k v)

1156 -> m (Event t (v a), Event t (DSum k (Product v (Compose (Event t) v))))

1155 -> m (Event t (v a), Event t (DSum k (Product v (Compose (Event t) v))))

1157factorEvent k0 kv' = do

1156factorEvent k0 kv' = do

1158− key :: Behavior t (Some k) <- hold (Some.This k0) $ fmapCheap (\(k :=> _) -> Some.This k) kv'

1157+ key :: Behavior t (Some k) <- hold (Some k0) $ fmapCheap (\(k :=> _) -> Some k) kv'

1159 let update = flip push kv' $ \(newKey :=> newVal) -> sample key >>= \case

1158 let update = flip push kv' $ \(newKey :=> newVal) -> sample key >>= \case

1160− Some.This oldKey -> case newKey `geq` oldKey of

1159+ Some oldKey -> case newKey `geq` oldKey of

1161 Just Refl -> return Nothing

1160 Just Refl -> return Nothing

1162 Nothing -> do

1161 Nothing -> do

1163 newInner <- filterEventKey newKey kv'

1162 newInner <- filterEventKey newKey kv'

src/Reflex/Patch/DMapWithMove.hs+3−4

@@ -30,8 +30,7 @@ import Data.GADT.Show (GShow, gshow)

30import qualified Data.Map as Map

31import Data.Maybe

32import Data.Semigroup (Semigroup (..), (<>))

33−import Data.Some (Some)

33+import Data.Some (Some(Some))

34−import qualified Data.Some as Some

35import Data.These

34import Data.These

37-- | Like 'PatchMapWithMove', but for 'DMap'. Each key carries a 'NodeInfo' which describes how it will be changed by the patch and connects move sources and

36-- | Like 'PatchMapWithMove', but for 'DMap'. Each key carries a 'NodeInfo' which describes how it will be changed by the patch and connects move sources and

@@ -311,8 +310,8 @@ weakenPatchDMapWithMoveWith f (PatchDMapWithMove p) = PatchMapWithMove $ weakenD

311 { MapWithMove._nodeInfo_from = case _nodeInfo_from ni of

310 { MapWithMove._nodeInfo_from = case _nodeInfo_from ni of

312 From_Insert v -> MapWithMove.From_Insert $ f v

311 From_Insert v -> MapWithMove.From_Insert $ f v

313 From_Delete -> MapWithMove.From_Delete

312 From_Delete -> MapWithMove.From_Delete

314− From_Move k -> MapWithMove.From_Move $ Some.This k

313+ From_Move k -> MapWithMove.From_Move $ Some k

315− , MapWithMove._nodeInfo_to = Some.This <$> getComposeMaybe (_nodeInfo_to ni)

314+ , MapWithMove._nodeInfo_to = Some <$> getComposeMaybe (_nodeInfo_to ni)

316 }

315 }

317

316

318-- |"Weaken" a @'PatchDMapWithMove' (Const2 k a) v@ to a @'PatchMapWithMove' k v'@. Weaken is in scare quotes because the 'Const2' has already disabled any

317-- |"Weaken" a @'PatchDMapWithMove' (Const2 k a) v@ to a @'PatchMapWithMove' k v'@. Weaken is in scare quotes because the 'Const2' has already disabled any

src/Reflex/Query/Base.hs+5−6

@@ -38,8 +38,7 @@ import Data.Map (Map)

38import qualified Data.Map as Map

39import Data.Monoid ((<>))

40import qualified Data.Semigroup as S

41−import Data.Some (Some)

41+import Data.Some (Some(Some))

42−import qualified Data.Some as Some

43import Data.These

42import Data.These

45import Reflex.Class

44import Reflex.Class

@@ -145,10 +144,10 @@ instance (Reflex t, MonadFix m, Group q, Additive q, Query q, Eq q, MonadHold t

145 liftedResult' = fforCheap result' $ \(PatchDMap p) -> PatchDMap $

144 liftedResult' = fforCheap result' $ \(PatchDMap p) -> PatchDMap $

146 mapKeyValuePairsMonotonic (\(k :=> ComposeMaybe mr) -> k :=> ComposeMaybe (fmap (getQueryTLoweredResultValue . getCompose) mr)) p

145 mapKeyValuePairsMonotonic (\(k :=> ComposeMaybe mr) -> k :=> ComposeMaybe (fmap (getQueryTLoweredResultValue . getCompose) mr)) p

147 liftedBs0 :: Map (Some k) [Behavior t q]

146 liftedBs0 :: Map (Some k) [Behavior t q]

148− liftedBs0 = Map.fromDistinctAscList $ (\(k :=> Compose r) -> (Some.This k, getQueryTLoweredResultWritten r)) <$> DMap.toList result0

147+ liftedBs0 = Map.fromDistinctAscList $ (\(k :=> Compose r) -> (Some k, getQueryTLoweredResultWritten r)) <$> DMap.toList result0

149 liftedBs' :: Event t (PatchMap (Some k) [Behavior t q])

148 liftedBs' :: Event t (PatchMap (Some k) [Behavior t q])

150 liftedBs' = fforCheap result' $ \(PatchDMap p) -> PatchMap $

149 liftedBs' = fforCheap result' $ \(PatchDMap p) -> PatchMap $

151− Map.fromDistinctAscList $ (\(k :=> ComposeMaybe mr) -> (Some.This k, fmap (getQueryTLoweredResultWritten . getCompose) mr)) <$> DMap.toList p

150+ Map.fromDistinctAscList $ (\(k :=> ComposeMaybe mr) -> (Some k, fmap (getQueryTLoweredResultWritten . getCompose) mr)) <$> DMap.toList p

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

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

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

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

154 accumBehaviors :: forall m'. MonadHold t m'

153 accumBehaviors :: forall m'. MonadHold t m'

@@ -189,10 +188,10 @@ instance (Reflex t, MonadFix m, Group q, Additive q, Query q, Eq q, MonadHold t

189 let liftedResult0 = mapKeyValuePairsMonotonic (\(k :=> Compose r) -> k :=> getQueryTLoweredResultValue r) result0

188 let liftedResult0 = mapKeyValuePairsMonotonic (\(k :=> Compose r) -> k :=> getQueryTLoweredResultValue r) result0

190 liftedResult' = fforCheap result' $ mapPatchDMapWithMove (getQueryTLoweredResultValue . getCompose)

189 liftedResult' = fforCheap result' $ mapPatchDMapWithMove (getQueryTLoweredResultValue . getCompose)

191 liftedBs0 :: Map (Some k) [Behavior t q]

190 liftedBs0 :: Map (Some k) [Behavior t q]

192− liftedBs0 = Map.fromDistinctAscList $ (\(k :=> Compose r) -> (Some.This k, getQueryTLoweredResultWritten r)) <$> DMap.toList result0

191+ liftedBs0 = Map.fromDistinctAscList $ (\(k :=> Compose r) -> (Some k, getQueryTLoweredResultWritten r)) <$> DMap.toList result0

193 liftedBs' :: Event t (PatchMapWithMove (Some k) [Behavior t q])

192 liftedBs' :: Event t (PatchMapWithMove (Some k) [Behavior t q])

194 liftedBs' = fforCheap result' $ weakenPatchDMapWithMoveWith (getQueryTLoweredResultWritten . getCompose) {- \(PatchDMap p) -> PatchMapWithMove $

193 liftedBs' = fforCheap result' $ weakenPatchDMapWithMoveWith (getQueryTLoweredResultWritten . getCompose) {- \(PatchDMap p) -> PatchMapWithMove $

195− Map.fromDistinctAscList $ (\(k :=> mr) -> (Some.This k, fmap (fmap (getQueryTLoweredResultWritten . getCompose)) mr)) <$> DMap.toList p -}

194+ Map.fromDistinctAscList $ (\(k :=> mr) -> (Some k, fmap (fmap (getQueryTLoweredResultWritten . getCompose)) mr)) <$> DMap.toList p -}

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

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

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

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

198 accumBehaviors' :: forall m'. MonadHold t m'

197 accumBehaviors' :: forall m'. MonadHold t m'

src/Reflex/Requester/Base.hs+2−3

@@ -66,8 +66,7 @@ import qualified Data.Map as Map

66import Data.Monoid ((<>))

67import Data.Proxy

68import qualified Data.Semigroup as S

69−import Data.Some (Some)

69+import Data.Some (Some(Some))

70−import qualified Data.Some as Some

71import Data.Type.Equality

70import Data.Type.Equality

72import Data.Unique.Tag

71import Data.Unique.Tag

@@ -441,7 +440,7 @@ traverseDMapWithKeyWithAdjustRequesterTWith base mapPatch weakenPatchWith patchN

441 pack = Entry

440 pack = Entry

442 f' :: forall a. k a -> Compose ((,) Int) v a -> m (Compose ((,) (Event t (IntMap (RequesterData request)))) v' a)

441 f' :: forall a. k a -> Compose ((,) Int) v a -> m (Compose ((,) (Event t (IntMap (RequesterData request)))) v' a)

443 f' k (Compose (n, v)) = do

442 f' k (Compose (n, v)) = do

444− (result, myRequests) <- runRequesterT (f k v) $ mapMaybeCheap (IntMap.lookup n) $ select responses (Const2 (Some.This k))

443+ (result, myRequests) <- runRequesterT (f k v) $ mapMaybeCheap (IntMap.lookup n) $ select responses (Const2 (Some k))

445 return $ Compose (fmapCheap (IntMap.singleton n) myRequests, result)

444 return $ Compose (fmapCheap (IntMap.singleton n) myRequests, result)

446 ndm' <- numberOccurrencesFrom 1 dm'

445 ndm' <- numberOccurrencesFrom 1 dm'

447 (children0, children') <- base f' (DMap.map (\v -> Compose (0, v)) dm0) $ fmap (\(n, dm) -> mapPatch (\v -> Compose (n, v)) dm) ndm'

446 (children0, children') <- base f' (DMap.map (\v -> Compose (0, v)) dm0) $ fmap (\(n, dm) -> mapPatch (\v -> Compose (n, v)) dm) ndm'

src/Reflex/Spider/Internal.hs+19−20

@@ -74,8 +74,7 @@ import Data.Tree (Forest, Tree (..), drawForest)

74import Data.FastWeakBag (FastWeakBag)

75import qualified Data.FastWeakBag as FastWeakBag

76import Data.Reflection

77−import Data.Some (Some)

77+import Data.Some (Some(Some))

78−import qualified Data.Some as Some

79import Data.Type.Coercion

78import Data.Type.Coercion

80import Data.WeakBag (WeakBag, WeakBagTicket, _weakBag_children)

79import Data.WeakBag (WeakBag, WeakBagTicket, _weakBag_children)

81import qualified Data.WeakBag as WeakBag

80import qualified Data.WeakBag as WeakBag

@@ -582,7 +581,7 @@ eventSubscribedFan !subscribed = EventSubscribed

582 { eventSubscribedHeightRef = eventSubscribedHeightRef $ _eventSubscription_subscribed $ fanSubscribedParent subscribed

581 { eventSubscribedHeightRef = eventSubscribedHeightRef $ _eventSubscription_subscribed $ fanSubscribedParent subscribed

583 , eventSubscribedRetained = toAny subscribed

582 , eventSubscribedRetained = toAny subscribed

584#ifdef DEBUG_CYCLES

583#ifdef DEBUG_CYCLES

585− , eventSubscribedGetParents = return [Some.This $ _eventSubscription_subscribed $ fanSubscribedParent subscribed]

584+ , eventSubscribedGetParents = return [Some $ _eventSubscription_subscribed $ fanSubscribedParent subscribed]

586 , eventSubscribedHasOwnHeightRef = False

585 , eventSubscribedHasOwnHeightRef = False

587 , eventSubscribedWhoCreated = whoCreatedIORef $ fanSubscribedCachedSubscribed subscribed

586 , eventSubscribedWhoCreated = whoCreatedIORef $ fanSubscribedCachedSubscribed subscribed

588#endif

587#endif

@@ -595,7 +594,7 @@ eventSubscribedSwitch !subscribed = EventSubscribed

595#ifdef DEBUG_CYCLES

594#ifdef DEBUG_CYCLES

596 , eventSubscribedGetParents = do

595 , eventSubscribedGetParents = do

597 s <- readIORef $ switchSubscribedCurrentParent subscribed

596 s <- readIORef $ switchSubscribedCurrentParent subscribed

598− return [Some.This $ _eventSubscription_subscribed s]

597+ return [Some $ _eventSubscription_subscribed s]

599 , eventSubscribedHasOwnHeightRef = True

598 , eventSubscribedHasOwnHeightRef = True

600 , eventSubscribedWhoCreated = whoCreatedIORef $ switchSubscribedCachedSubscribed subscribed

599 , eventSubscribedWhoCreated = whoCreatedIORef $ switchSubscribedCachedSubscribed subscribed

601#endif

600#endif

@@ -608,8 +607,8 @@ eventSubscribedCoincidence !subscribed = EventSubscribed

608#ifdef DEBUG_CYCLES

607#ifdef DEBUG_CYCLES

609 , eventSubscribedGetParents = do

608 , eventSubscribedGetParents = do

610 innerSubscription <- readIORef $ coincidenceSubscribedInnerParent subscribed

609 innerSubscription <- readIORef $ coincidenceSubscribedInnerParent subscribed

611− let outerParent = Some.This $ _eventSubscription_subscribed $ coincidenceSubscribedOuterParent subscribed

610+ let outerParent = Some $ _eventSubscription_subscribed $ coincidenceSubscribedOuterParent subscribed

612− innerParents = maybeToList $ fmap Some.This innerSubscription

611+ innerParents = maybeToList $ fmap Some innerSubscription

613 return $ outerParent : innerParents

612 return $ outerParent : innerParents

614 , eventSubscribedHasOwnHeightRef = True

613 , eventSubscribedHasOwnHeightRef = True

615 , eventSubscribedWhoCreated = whoCreatedIORef $ coincidenceSubscribedCachedSubscribed subscribed

614 , eventSubscribedWhoCreated = whoCreatedIORef $ coincidenceSubscribedCachedSubscribed subscribed

@@ -625,13 +624,13 @@ whoCreatedEventSubscribed = eventSubscribedWhoCreated

625

624

626walkInvalidHeightParents :: EventSubscribed x -> IO [Some (EventSubscribed x)]

625walkInvalidHeightParents :: EventSubscribed x -> IO [Some (EventSubscribed x)]

627walkInvalidHeightParents s0 = do

626walkInvalidHeightParents s0 = do

628− subscribers <- flip execStateT mempty $ ($ Some.This s0) $ fix $ \loop (Some.This s) -> do

627+ subscribers <- flip execStateT mempty $ ($ Some s0) $ fix $ \loop (Some s) -> do

629 h <- liftIO $ readIORef $ eventSubscribedHeightRef s

628 h <- liftIO $ readIORef $ eventSubscribedHeightRef s

630 when (h == invalidHeight) $ do

629 when (h == invalidHeight) $ do

631 when (eventSubscribedHasOwnHeightRef s) $ liftIO $ writeIORef (eventSubscribedHeightRef s) $! invalidHeightBeingTraversed

630 when (eventSubscribedHasOwnHeightRef s) $ liftIO $ writeIORef (eventSubscribedHeightRef s) $! invalidHeightBeingTraversed

632− modify (Some.This s :)

631+ modify (Some s :)

633 mapM_ loop =<< liftIO (eventSubscribedGetParents s)

632 mapM_ loop =<< liftIO (eventSubscribedGetParents s)

634− forM_ subscribers $ \(Some.This s) -> writeIORef (eventSubscribedHeightRef s) $! invalidHeight

633+ forM_ subscribers $ \(Some s) -> writeIORef (eventSubscribedHeightRef s) $! invalidHeight

635 return subscribers

634 return subscribers

636#endif

635#endif

637

636

@@ -659,7 +658,7 @@ behaviorPull !p = Behavior $ do

659 val <- liftIO $ readIORef $ pullValue p

658 val <- liftIO $ readIORef $ pullValue p

660 case val of

659 case val of

661 Just subscribed -> do

660 Just subscribed -> do

662− askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (Some.This (BehaviorSubscribedPull subscribed)) :))

661+ askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (Some (BehaviorSubscribedPull subscribed)) :))

663 askInvalidator >>= mapM_ (\wi -> liftIO $ modifyIORef' (pullSubscribedInvalidators subscribed) (wi:))

662 askInvalidator >>= mapM_ (\wi -> liftIO $ modifyIORef' (pullSubscribedInvalidators subscribed) (wi:))

664 liftIO $ touch $ pullSubscribedOwnInvalidator subscribed

663 liftIO $ touch $ pullSubscribedOwnInvalidator subscribed

665 return $ pullSubscribedValue subscribed

664 return $ pullSubscribedValue subscribed

@@ -678,7 +677,7 @@ behaviorPull !p = Behavior $ do

678 , pullSubscribedParents = parents

677 , pullSubscribedParents = parents

679 }

678 }

680 liftIO $ writeIORef (pullValue p) $ Just subscribed

679 liftIO $ writeIORef (pullValue p) $ Just subscribed

681− askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (Some.This (BehaviorSubscribedPull subscribed)) :))

680+ askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (Some (BehaviorSubscribedPull subscribed)) :))

682 return a

681 return a

683

682

684behaviorDyn :: Patch p => Dyn x p -> Behavior x (PatchTarget p)

683behaviorDyn :: Patch p => Dyn x p -> Behavior x (PatchTarget p)

@@ -689,7 +688,7 @@ readHoldTracked :: Hold x p -> BehaviorM x (PatchTarget p)

689readHoldTracked h = do

688readHoldTracked h = do

690 result <- liftIO $ readIORef $ holdValue h

689 result <- liftIO $ readIORef $ holdValue h

691 askInvalidator >>= mapM_ (\wi -> liftIO $ modifyIORef' (holdInvalidators h) (wi:))

690 askInvalidator >>= mapM_ (\wi -> liftIO $ modifyIORef' (holdInvalidators h) (wi:))

692− askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (Some.This (BehaviorSubscribedHold h)) :))

691+ askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (Some (BehaviorSubscribedHold h)) :))

693 liftIO $ touch h -- Otherwise, if this gets inlined enough, the hold's parent reference may get collected

692 liftIO $ touch h -- Otherwise, if this gets inlined enough, the hold's parent reference may get collected

694 return result

693 return result

695

694

@@ -862,7 +861,7 @@ instance HasSpiderTimeline x => Defer (Some Clear) (EventM x) where

862

861

863{-# INLINE scheduleClear #-}

862{-# INLINE scheduleClear #-}

864scheduleClear :: Defer (Some Clear) m => IORef (Maybe a) -> m ()

863scheduleClear :: Defer (Some Clear) m => IORef (Maybe a) -> m ()

865−scheduleClear r = defer $ Some.This $ Clear r

864+scheduleClear r = defer $ Some $ Clear r

866

865

867instance HasSpiderTimeline x => Defer (Some IntClear) (EventM x) where

866instance HasSpiderTimeline x => Defer (Some IntClear) (EventM x) where

868 {-# INLINE getDeferralQueue #-}

867 {-# INLINE getDeferralQueue #-}

@@ -870,7 +869,7 @@ instance HasSpiderTimeline x => Defer (Some IntClear) (EventM x) where

870

869

871{-# INLINE scheduleIntClear #-}

870{-# INLINE scheduleIntClear #-}

872scheduleIntClear :: Defer (Some IntClear) m => IORef (IntMap a) -> m ()

871scheduleIntClear :: Defer (Some IntClear) m => IORef (IntMap a) -> m ()

873−scheduleIntClear r = defer $ Some.This $ IntClear r

872+scheduleIntClear r = defer $ Some $ IntClear r

874

873

875instance HasSpiderTimeline x => Defer (Some RootClear) (EventM x) where

874instance HasSpiderTimeline x => Defer (Some RootClear) (EventM x) where

876 {-# INLINE getDeferralQueue #-}

875 {-# INLINE getDeferralQueue #-}

@@ -878,7 +877,7 @@ instance HasSpiderTimeline x => Defer (Some RootClear) (EventM x) where

878

877

879{-# INLINE scheduleRootClear #-}

878{-# INLINE scheduleRootClear #-}

880scheduleRootClear :: Defer (Some RootClear) m => IORef (DMap k Identity) -> m ()

879scheduleRootClear :: Defer (Some RootClear) m => IORef (DMap k Identity) -> m ()

881−scheduleRootClear r = defer $ Some.This $ RootClear r

880+scheduleRootClear r = defer $ Some $ RootClear r

882

881

883instance HasSpiderTimeline x => Defer (SomeResetCoincidence x) (EventM x) where

882instance HasSpiderTimeline x => Defer (SomeResetCoincidence x) (EventM x) where

884 {-# INLINE getDeferralQueue #-}

883 {-# INLINE getDeferralQueue #-}

@@ -1853,7 +1852,7 @@ mergeSubscriber m getKey = Subscriber

1853 else liftIO $ do

1852 else liftIO $ do

1854#ifdef DEBUG_CYCLES

1853#ifdef DEBUG_CYCLES

1855 nodesInvolvedInCycle <- walkInvalidHeightParents $ eventSubscribedMerge subscribed

1854 nodesInvolvedInCycle <- walkInvalidHeightParents $ eventSubscribedMerge subscribed

1856− stacks <- forM nodesInvolvedInCycle $ \(Some.This es) -> whoCreatedEventSubscribed es

1855+ stacks <- forM nodesInvolvedInCycle $ \(Some es) -> whoCreatedEventSubscribed es

1857 let cycleInfo = ":\n" <> drawForest (listsToForest stacks)

1856 let cycleInfo = ":\n" <> drawForest (listsToForest stacks)

1858#else

1857#else

1859 let cycleInfo = ""

1858 let cycleInfo = ""

@@ -2096,11 +2095,11 @@ runFrame a = SpiderHost $ do

2096 return result

2095 return result

2097 result <- runEventM go

2096 result <- runEventM go

2098 toClear <- readIORef $ eventEnvClears env

2097 toClear <- readIORef $ eventEnvClears env

2099− forM_ toClear $ \(Some.This (Clear ref)) -> {-# SCC "clear" #-} writeIORef ref Nothing

2098+ forM_ toClear $ \(Some (Clear ref)) -> {-# SCC "clear" #-} writeIORef ref Nothing

2100 toClearInt <- readIORef $ eventEnvIntClears env

2099 toClearInt <- readIORef $ eventEnvIntClears env

2101− forM_ toClearInt $ \(Some.This (IntClear ref)) -> {-# SCC "intClear" #-} writeIORef ref $! IntMap.empty

2100+ forM_ toClearInt $ \(Some (IntClear ref)) -> {-# SCC "intClear" #-} writeIORef ref $! IntMap.empty

2102 toClearRoot <- readIORef $ eventEnvRootClears env

2101 toClearRoot <- readIORef $ eventEnvRootClears env

2103− forM_ toClearRoot $ \(Some.This (RootClear ref)) -> {-# SCC "rootClear" #-} writeIORef ref $! DMap.empty

2102+ forM_ toClearRoot $ \(Some (RootClear ref)) -> {-# SCC "rootClear" #-} writeIORef ref $! DMap.empty

2104 toAssign <- readIORef $ eventEnvAssignments env

2103 toAssign <- readIORef $ eventEnvAssignments env

2105 toReconnectRef <- newIORef []

2104 toReconnectRef <- newIORef []

2106 coincidenceInfos <- readIORef $ eventEnvResetCoincidences env

2105 coincidenceInfos <- readIORef $ eventEnvResetCoincidences env

@@ -2460,7 +2459,7 @@ unsafeNewSpiderTimelineEnv = do

2460

2459

2461-- | Create a new SpiderTimelineEnv

2460-- | Create a new SpiderTimelineEnv

2462newSpiderTimeline :: IO (Some SpiderTimelineEnv)

2461newSpiderTimeline :: IO (Some SpiderTimelineEnv)

2463−newSpiderTimeline = withSpiderTimeline (pure . Some.This)

2462+newSpiderTimeline = withSpiderTimeline (pure . Some)

2464

2463

2465data LocalSpiderTimeline x s

2464data LocalSpiderTimeline x s

2466

2465