8572da6 · patch · git.iko.soy

git.iko.soy/patch

Merge remote-tracking branch 'origin/develop' into patchmapwithmove2

commit8572da6b43d33b1417b5bcc94e08d8bb40316d77 authorJohn Ericson <John.Ericson@Obsidian.Systems> dateWed 11 Dec 2019, 15:58 (7 years ago) parent49478e8 cc8d123

15 files changed+119−187

compare with develop

unifiedsplit

ChangeLog.md+7 default.nix−43 dep/reflex-platform/default.nix+7 dep/reflex-platform/github.json+7 hydra.json−29 jobsets.nix−70 reflex-platform.nix−8 reflex.cabal+1−1 release.nix+43−7 src/Data/FastWeakBag.hs+9−4 src/Data/WeakBag.hs+8−3 src/Reflex/Class.hs+8−2 src/Reflex/Collection.hs+4−1 src/Reflex/Patch/MapWithMove.hs+1−1 src/Reflex/Spider/Internal.hs+24−18

ChangeLog.md+7

@@ -1,5 +1,12 @@

11# Revision history for reflex

3+## Unreleased

5+* Data.WeakBag.traverse and Data.FastWeakBag.traverse have been

6+ renamed to Data.WeakBag.traverse_ and Data.FastWeakBag.traverse_

7+ respectively.

8+* Fixes a bug in `Reflex.Patch.MapWithMove.patchThatSortsMapWith` that was producing invalid `PatchMapWithMove`.

310## 0.6.2.4

411

512* Update to monoidal-containers 0.6

default.nixdeleted−43

@@ -1,43 +0,0 @@

1−{ mkDerivation, ghc, base, bifunctors, containers, deepseq

2−, dependent-map, dependent-sum, exception-transformers

3−, haskell-src-exts, haskell-src-meta, hlint, lens, MemoTrie

4−, monad-control, mtl, primitive, random, ref-tf

5−, semigroupoids , semigroups, split, stdenv, stm, syb

6−, template-haskell , these, time, transformers

7−, transformers-compat, unbounded-delays, prim-uniq

8−, data-default, filepath, directory, filemanip, ghcjs-base

9−, monoidal-containers, witherable, constraints-extras, profunctors

10−, semialign ? null, splitThese ? (semialign != null)

11−, useTemplateHaskell ? true

12−}:

13−mkDerivation {

14− pname = "reflex";

15− version = "0.6.2.4";

16− src = builtins.filterSource (path: type: !(builtins.elem (baseNameOf path) [ ".git" "dist" ])) ./.;

17− libraryHaskellDepends = [

18− base bifunctors containers dependent-map dependent-sum

19− exception-transformers lens

20− MemoTrie monad-control mtl primitive ref-tf semigroupoids

21− semigroups stm syb template-haskell these transformers

22− transformers-compat prim-uniq

23− base bifunctors containers deepseq dependent-map dependent-sum

24− mtl ref-tf split transformers data-default

25− random time unbounded-delays monoidal-containers witherable

26− constraints-extras profunctors

27− ] ++ (if ghc.isGhcjs or false then [

28− ghcjs-base

29− ] else []) ++ (if !useTemplateHaskell then [] else [

30− haskell-src-exts haskell-src-meta

31− ]) ++ (if splitThese then [

32− semialign

33− ] else []);

34− testHaskellDepends = if ghc.isGhcjs or false then [] else [

35− hlint filepath directory filemanip

36− ];

37− configureFlags =

38− stdenv.lib.optional (!useTemplateHaskell) [ "-f-use-template-haskell" ] ++

39− stdenv.lib.optional (!splitThese) [ "-f-split-these" ];

40− homepage = "https://github.com/reflex-frp/reflex";

41− description = "Higher-order Functional Reactive Programming";

42− license = stdenv.lib.licenses.bsd3;

43−}

dep/reflex-platform/default.nixnew file+7

@@ -0,0 +1,7 @@

1+# DO NOT HAND-EDIT THIS FILE

2+import ((import <nixpkgs> {}).fetchFromGitHub (

3+ let json = builtins.fromJSON (builtins.readFile ./github.json);

4+ in { inherit (json) owner repo rev sha256;

5+ private = json.private or false;

6+ }

7+))

dep/reflex-platform/github.jsonnew file+7

@@ -0,0 +1,7 @@

1+{

2+ "owner": "reflex-frp",

3+ "repo": "reflex-platform",

4+ "branch": "jailbreakTheselens",

5+ "rev": "4284ed527c96c373538dc7e31776d9a50ca6aa91",

6+ "sha256": "1m1nkxq7ng9wnqbd77xn8d81f2iz8g61y5m0r3gp0gi0q59jm8ay"

7+}

hydra.jsondeleted−29

@@ -1,29 +0,0 @@

1−{

2− "enabled": 1,

3− "hidden": true,

4− "description": "Jobsets",

5− "nixexprinput": "src",

6− "nixexprpath": "jobsets.nix",

7− "checkinterval": 300,

8− "schedulingshares": 100,

9− "enableemail": false,

10− "emailoverride": "",

11− "keepnr": 10,

12− "inputs": {

13− "src": {

14− "type": "git",

15− "value": "https://github.com/reflex-frp/reflex.git develop",

16− "emailresponsible": false

17− },

18− "nixpkgs": {

19− "type": "git",

20− "value": "https://github.com/NixOS/nixpkgs-channels nixos-unstable",

21− "emailresponsible": false

22− },

23− "prs": {

24− "type": "githubpulls",

25− "value": "reflex-frp reflex",

26− "emailresponsible": false

27− }

28− }

29−}

jobsets.nixdeleted−70

@@ -1,70 +0,0 @@

1−{ prs }:

2−

3−let

4− pkgs = (import ./reflex-platform.nix {}).nixpkgs;

5− mkFetchGithub = value: {

6− inherit value;

7− type = "git";

8− emailresponsible = false;

9− };

10−in

11−with pkgs.lib;

12−let

13− defaults = jobs: {

14− inherit (jobs) description;

15− enabled = 1;

16− hidden = false;

17− keepnr = 10;

18− schedulingshares = 100;

19− checkinterval = 120;

20− enableemail = false;

21− emailoverride = "";

22− nixexprinput = "reflex";

23− nixexprpath = "release.nix";

24− inputs = jobs.inputs // {

25− nixpkgs = {

26− type = "git";

27− value = "https://github.com/NixOS/nixpkgs-channels nixos-unstable";

28− emailresponsible = false;

29− };

30− config = {

31− type = "nix";

32− value = "{ android_sdk.accept_license = true; }";

33− emailresponsible = false;

34− };

35− };

36− };

37− branchJobset = branch: defaults {

38− description = "reflex-${branch}";

39− inputs = {

40− reflex = {

41− value = "https://github.com/reflex-frp/reflex ${branch}";

42− type = "git";

43− emailresponsible = false;

44− };

45− };

46− };

47− makePr = num: info: {

48− name = "reflex-pr-${num}";

49− value = defaults {

50− description = "#${num}: ${info.title}";

51− inputs = {

52− reflex = {

53− #NOTE: This should really use "pull/${num}/merge"; however, GitHub's

54− #status checks only operate on PR heads. This creates a race

55− #condition, which can currently only be solved by requiring PRs to be

56− #up to date before they're merged. See

57− #https://github.com/isaacs/github/issues/1002

58− value = "https://github.com/reflex-frp/reflex pull/${num}/head";

59− type = "git";

60− emailresponsible = false;

61− };

62− };

63− };

64− };

65− processedPrs = mapAttrs' makePr (builtins.fromJSON (builtins.readFile prs));

66− jobsetsAttrs = processedPrs //

67− genAttrs ["develop"] branchJobset;

68−in {

69− jobsets = pkgs.writeText "spec.json" (builtins.toJSON jobsetsAttrs);

70−}

reflex-platform.nixdeleted−8

@@ -1,8 +0,0 @@

1−let

2− reflex-platform-src = (import <nixpkgs> {}).fetchFromGitHub {

3− owner = "reflex-frp";

4− repo = "reflex-platform";

5− rev = "384cd850f3adf1d404bced2424b5f6efb0f415f2";

6− sha256 = "1ws77prqx8khmp8j6br1ij4k2v4dlgv170r9fmg0p1jivfbn8y9d";

7− };

8−in import reflex-platform-src

reflex.cabal+1−1

@@ -78,7 +78,7 @@ library

7878

7979 if flag(split-these)

8080 build-depends: these >= 1 && <1.1,

81− semialign >=1 && <1.1,

81+ semialign >=1 && <1.2,

8282 monoidal-containers >= 0.6 && < 0.7

8383 else

8484 build-depends: these >= 0.4 && <0.9,

release.nix+43−7

@@ -1,9 +1,45 @@

1−{ rp ? import ./reflex-platform.nix {}

1+{ reflex-platform-fun ? import ./dep/reflex-platform

22}:

34let

4− inherit (rp.nixpkgs) lib;

5− compilers = ["ghc8_4" "ghc8_0" "ghcjs8_4" "ghcjs8_0"];

6−in lib.attrValues (lib.genAttrs compilers (ghc: {

7− reflex-useTemplateHaskell = rp.${ghc}.callPackage ./. { useTemplateHaskell = true; splitThese = false; };

8− reflex = rp.${ghc}.callPackage ./. { useTemplateHaskell = false; splitThese = false; };

9−}))

5+ native-reflex-platform = reflex-platform-fun {};

6+ inherit (native-reflex-platform.nixpkgs) lib;

7+ systems = ["x86_64-linux" "x86_64-darwin"];

9+ perPlatform = lib.genAttrs systems (system: let

10+ reflex-platform = reflex-platform-fun { inherit system; };

11+ compilers = [

12+ "ghc"

13+ "ghcjs"

14+ ] ++ lib.optionals (reflex-platform.androidSupport) [

15+ "ghcAndroidAarch64"

16+ "ghcAndroidAarch32"

17+ ] ++ lib.optionals (reflex-platform.iosSupport) [

18+ "ghcIosAarch64"

19+ ];

20+ hsPkgs = lib.genAttrs compilers (ghc: let

21+ ghc' = reflex-platform.${ghc}.override {

22+ overrides = self: super: let

23+ reflexSrc = builtins.filterSource (path: type: !(builtins.elem (baseNameOf path) [

24+ "default.nix"

25+ "release.nix"

26+ ".git"

27+ "dist"

28+ ])) ./.;

29+ in {

30+ reflex-dontUseTemplateHaskell = self.callCabal2nixWithOptions "reflex" reflexSrc "-f -use-template-haskell" {};

31+ reflex = self.callCabal2nixWithOptions "reflex" reflexSrc "-f +use-template-haskell" {};

32+ };

33+ };

34+ in {

35+ inherit (ghc') reflex reflex-dontUseTemplateHaskell;

36+ });

37+ in hsPkgs // {

38+ cache = reflex-platform.pinBuildInputs "reflex-${system}"

39+ (lib.concatLists (map builtins.attrValues (builtins.attrValues hsPkgs)));

40+ });

41+

42+ metaCache = native-reflex-platform.pinBuildInputs "reflex-everywhere"

43+ (map (a: a.cache) (builtins.attrValues perPlatform));

44+

45+in perPlatform // { inherit metaCache; }

src/Data/FastWeakBag.hs+9−4

@@ -18,6 +18,7 @@ module Data.FastWeakBag

1818 , isEmpty

1919 , insert

2020 , traverse

21+ , traverse_

2122 , remove

2223 -- * Internal functions

2324 -- These will not always be available.

@@ -116,14 +117,14 @@ foreign import javascript unsafe "(function(){ for(var i = 0; i < $1.tickets.len

116117isEmpty bag = {-# SCC "isEmpty" #-} IntMap.null <$> readIORef (_weakBag_children bag)

117118#endif

118119

119−{-# INLINE traverse #-}

120+{-# INLINE traverse_ #-}

120121-- | Visit every node in the given list. If new nodes are appended during the

121122-- traversal, they will not be visited. Every live node that was in the list

122123-- when the traversal began will be visited exactly once; however, no guarantee

123124-- is made about the order of the traversal.

124−traverse :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()

125+traverse_ :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()

125126#ifdef GHCJS_FAST_WEAK

126−traverse wb f = do

127+traverse_ wb f = do

127128 let go cursor = when (not $ js_isNull cursor) $ do

128129 val <- liftIO $ js_getTicketValue cursor

129130 f $ unsafeFromRawJSVal val

@@ -134,13 +135,17 @@ foreign import javascript unsafe "$r = $1.val;" js_getTicketValue :: JSVal -> IO

134135--TODO: Fix the race condition where if a cursor is deleted (presumably using 'remove', below) while we're holding it, it can't find its way back to the correct bag

135136foreign import javascript unsafe "(function(){ for(var i = $1.pos - 1; i >= 0; i--) { if($1.bag.tickets[i] !== null) { return $1.bag.tickets[i]; } }; return null; })()" js_getNext :: FastWeakBagTicket a -> IO JSVal --TODO: Clean up as we go along so this isn't O(n) every time -- Result can be null or a FastWeakBagTicket a

136137#else

137−traverse (FastWeakBag _ children) f = {-# SCC "traverse" #-} do

138+traverse_ (FastWeakBag _ children) f = {-# SCC "traverse_" #-} do

138139 cs <- liftIO $ readIORef children

139140 forM_ cs $ \c -> do

140141 ma <- liftIO $ deRefWeak c

141142 mapM_ f ma

142143#endif

143144

145+{-# DEPRECATED traverse "Use 'traverse_' instead" #-}

146+traverse :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()

147+traverse = traverse_

148+

144149-- | Remove an item from the 'FastWeakBag'; does nothing if invoked multiple times

145150-- on the same 'FastWeakBagTicket'.

146151{-# INLINE remove #-}

src/Data/WeakBag.hs+8−3

@@ -15,6 +15,7 @@ module Data.WeakBag

1515 , singleton

1616 , insert

1717 , traverse

18+ , traverse_

1819 , remove

1920 -- * Internal functions

2021 -- These will not always be available.

@@ -99,18 +100,22 @@ singleton a wbRef finalizer = {-# SCC "singleton" #-} do

99100 ticket <- insert a bag wbRef finalizer

100101 return (bag, ticket)

101102

102−{-# INLINE traverse #-}

103+{-# INLINE traverse_ #-}

103104-- | Visit every node in the given list. If new nodes are appended during the

104105-- traversal, they will not be visited. Every live node that was in the list

105106-- when the traversal began will be visited exactly once; however, no guarantee

106107-- is made about the order of the traversal.

107−traverse :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()

108−traverse (WeakBag _ children) f = {-# SCC "traverse" #-} do

108+traverse_ :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()

109+traverse_ (WeakBag _ children) f = {-# SCC "traverse" #-} do

109110 cs <- liftIO $ readIORef children

110111 forM_ cs $ \c -> do

111112 ma <- liftIO $ deRefWeak c

112113 mapM_ f ma

113114

115+{-# DEPRECATED traverse "Use 'traverse_' instead" #-}

116+traverse :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()

117+traverse = traverse_

118+

114119-- | Remove an item from the 'WeakBag'; does nothing if invoked multiple times

115120-- on the same 'WeakBagTicket'.

116121{-# INLINE remove #-}

src/Reflex/Class.hs+8−2

@@ -173,12 +173,15 @@ module Reflex.Class

173173 , slowHeadE

174174 ) where

175175

176−#if defined(MIN_VERSION_semialign)

176+#ifdef MIN_VERSION_semialign

177177import Prelude hiding (zip, zipWith)

178178

179179#if MIN_VERSION_these(0,8,0)

180180import Data.These.Combinators (justThese)

181181#endif

182+#if MIN_VERSION_semialign(1,1,0)

183+import Data.Zip (Zip (..))

184+#endif

182185#endif

183186

184187import Control.Applicative

@@ -1077,7 +1080,10 @@ instance Reflex t => Semialign (Event t) where

10771080#endif

10781081 align = alignEventWithMaybe Just

10791082

1080−#if defined(MIN_VERSION_semialign)

1083+#ifdef MIN_VERSION_semialign

1084+#if MIN_VERSION_semialign(1,1,0)

1085+instance Reflex t => Zip (Event t) where

1086+#endif

10811087 zip x y = mapMaybe justThese $ align x y

10821088#endif

10831089

src/Reflex/Collection.hs+4−1

@@ -27,8 +27,11 @@ module Reflex.Collection

2727 , simpleList

2828 ) where

2929

30−#if defined(MIN_VERSION_semialign)

30+#ifdef MIN_VERSION_semialign

3131import Prelude hiding (zip, zipWith)

32+#if MIN_VERSION_semialign(1,1,0)

33+import Data.Zip (Zip (..))

34+#endif

3235#endif

3336

3437import Control.Monad.Identity

src/Reflex/Patch/MapWithMove.hs+1−1

@@ -155,7 +155,7 @@ patchThatSortsMapWith cmp m = PatchMapWithMove $ Map.fromList $ catMaybes $ zipW

155155 Just (from, to)

156156 reverseMapping = Map.fromList $ catMaybes $ zipWith f unsorted sorted

157157 g (to, _) (from, _) = if to == from then Nothing else

158− let Just movingTo = Map.lookup from reverseMapping

158+ let Just movingTo = Map.lookup to reverseMapping

159159 in Just (to, NodeInfo (From_Move from) $ Just movingTo)

160160

161161-- | Create a 'PatchMapWithMove' that, if applied to the first 'Map' provided,

src/Reflex/Spider/Internal.hs+24−18

@@ -72,10 +72,13 @@ import System.IO.Unsafe

7272import System.Mem.Weak

7373import Unsafe.Coerce

7474

75−#if defined(MIN_VERSION_semialign)

75+#ifdef MIN_VERSION_semialign

7676#if MIN_VERSION_these(0,8,0)

7777import Data.These.Combinators (justThese)

7878#endif

79+#if MIN_VERSION_semialign(1,1,0)

80+import Data.Zip (Zip (..))

81+#endif

7982#endif

8083

8184#ifdef DEBUG_CYCLES

@@ -329,9 +332,9 @@ cacheEvent e =

329332 scheduleClear occRef

330333 propagateFast a subscribers

331334 , subscriberInvalidateHeight = \old -> do

332− FastWeakBag.traverse subscribers $ invalidateSubscriberHeight old

335+ FastWeakBag.traverse_ subscribers $ invalidateSubscriberHeight old

333336 , subscriberRecalculateHeight = \new -> do

334− FastWeakBag.traverse subscribers $ recalculateSubscriberHeight new

337+ FastWeakBag.traverse_ subscribers $ recalculateSubscriberHeight new

335338 }

336339 when (isJust occ) $ do

337340 liftIO $ writeIORef occRef occ -- Set the initial value of occRef; we don't need to do this if occ is Nothing

@@ -447,12 +450,12 @@ newSubscriberFan subscribed = return $ Subscriber

447450 , subscriberInvalidateHeight = \old -> do

448451 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed

449452 subscribers <- readIORef $ fanSubscribedSubscribers subscribed

450− forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old

453+ forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse_ (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old

451454 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"

452455 , subscriberRecalculateHeight = \new -> do

453456 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed

454457 subscribers <- readIORef $ fanSubscribedSubscribers subscribed

455− forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new

458+ forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse_ (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new

456459 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"

457460 }

458461

@@ -468,7 +471,7 @@ newSubscriberSwitch subscribed = return $ Subscriber

468471 oldHeight <- readIORef $ switchSubscribedHeight subscribed

469472 when (oldHeight /= invalidHeight) $ do

470473 writeIORef (switchSubscribedHeight subscribed) $! invalidHeight

471− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

474+ WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

472475 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"

473476 , subscriberRecalculateHeight = \new -> do

474477 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed

@@ -491,8 +494,8 @@ newSubscriberCoincidenceOuter subscribed = return $ Subscriber

491494 Nothing -> do

492495 when (innerHeight > outerHeight) $ liftIO $ do -- If the event fires, it will fire at a later height

493496 writeIORef (coincidenceSubscribedHeight subscribed) $! innerHeight

494− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight

495− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight

497+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight

498+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight

496499 Just o -> do -- Since it's already firing, no need to adjust height

497500 liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) occ

498501 scheduleClear $ coincidenceSubscribedOccurrence subscribed

@@ -539,14 +542,14 @@ propagate :: a -> WeakBag (Subscriber x a) -> EventM x ()

539542propagate a subscribers = withIncreasedDepth $ do

540543 -- Note: in the following traversal, we do not visit nodes that are added to the list during our traversal; they are new events, which will necessarily have full information already, so there is no need to traverse them

541544 --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work

542− WeakBag.traverse subscribers $ \s -> subscriberPropagate s a

545+ WeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a

543546

544547-- | Propagate everything at the current height

545548propagateFast :: a -> FastWeakBag (Subscriber x a) -> EventM x ()

546549propagateFast a subscribers = withIncreasedDepth $ do

547550 -- Note: in the following traversal, we do not visit nodes that are added to the list during our traversal; they are new events, which will necessarily have full information already, so there is no need to traverse them

548551 --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work

549− FastWeakBag.traverse subscribers $ \s -> subscriberPropagate s a

552+ FastWeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a

550553

551554--------------------------------------------------------------------------------

552555-- EventSubscribed

@@ -1163,7 +1166,10 @@ instance HasSpiderTimeline x => Semialign (Event x) where

11631166 align ea eb = mapMaybe dmapToThese $ mergeG coerce $ dynamicConst $

11641167 DMap.fromDistinctAscList [LeftTag :=> ea, RightTag :=> eb]

11651168

1166−#if defined(MIN_VERSION_semialign)

1169+#ifdef MIN_VERSION_semialign

1170+#if MIN_VERSION_semialign(1,1,0)

1171+instance HasSpiderTimeline x => Zip (Event x) where

1172+#endif

11671173 zip x y = mapMaybe justThese $ align x y

11681174#endif

11691175

@@ -1521,15 +1527,15 @@ fanInt p = unsafePerformIO $ do

15211527 liftIO $ writeIORef (_fanInt_occRef self) m

15221528 scheduleIntClear $ _fanInt_occRef self

15231529 FastMutableIntMap.forIntersectionWithImmutable_ (_fanInt_subscribers self) m $ \b v -> do --TODO: Do we need to know that no subscribers are being added as we traverse?

1524− FastWeakBag.traverse b $ \s -> do

1530+ FastWeakBag.traverse_ b $ \s -> do

15251531 subscriberPropagate s v

15261532 , subscriberInvalidateHeight = \old -> do

15271533 FastMutableIntMap.for_ (_fanInt_subscribers self) $ \b -> do

1528− FastWeakBag.traverse b $ \s -> do

1534+ FastWeakBag.traverse_ b $ \s -> do

15291535 subscriberInvalidateHeight s old

15301536 , subscriberRecalculateHeight = \new -> do

15311537 FastMutableIntMap.for_ (_fanInt_subscribers self) $ \b -> do

1532− FastWeakBag.traverse b $ \s -> do

1538+ FastWeakBag.traverse_ b $ \s -> do

15331539 subscriberRecalculateHeight s new

15341540 }

15351541 liftIO $ do

@@ -2201,7 +2207,7 @@ runFrame a = SpiderHost $ do

22012207 myHeight <- readIORef $ switchSubscribedHeight subscribed

22022208 when (parentHeight /= myHeight) $ do

22032209 writeIORef (switchSubscribedHeight subscribed) $! invalidHeight

2204− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight

2210+ WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight

22052211 mapM_ _someMergeUpdate_invalidateHeight mergeUpdates --TODO: In addition to when the patch is completely empty, we should also not run this if it has some Nothing values, but none of them have actually had any effect; potentially, we could even check for Just values with no effect (e.g. by comparing their IORefs and ignoring them if they are unchanged); actually, we could just check if the new height is different

22062212 forM_ coincidenceInfos $ \(SomeResetCoincidence subscription mcs) -> do

22072213 unsubscribe subscription

@@ -2242,7 +2248,7 @@ invalidateCoincidenceHeight subscribed = do

22422248 oldHeight <- readIORef $ coincidenceSubscribedHeight subscribed

22432249 when (oldHeight /= invalidHeight) $ do

22442250 writeIORef (coincidenceSubscribedHeight subscribed) $! invalidHeight

2245− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

2251+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

22462252

22472253updateSwitchHeight :: Height -> SwitchSubscribed x a -> IO ()

22482254updateSwitchHeight new subscribed = do

@@ -2250,7 +2256,7 @@ updateSwitchHeight new subscribed = do

22502256 when (oldHeight == invalidHeight) $ do --TODO: This 'when' should probably be an assertion

22512257 when (new /= invalidHeight) $ do --TODO: This 'when' should probably be an assertion

22522258 writeIORef (switchSubscribedHeight subscribed) $! new

2253− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new

2259+ WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new

22542260

22552261recalculateCoincidenceHeight :: CoincidenceSubscribed x a -> IO ()

22562262recalculateCoincidenceHeight subscribed = do

@@ -2259,7 +2265,7 @@ recalculateCoincidenceHeight subscribed = do

22592265 height <- calculateCoincidenceHeight subscribed

22602266 when (height /= invalidHeight) $ do

22612267 writeIORef (coincidenceSubscribedHeight subscribed) $! height

2262− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height

2268+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height

22632269

22642270calculateSwitchHeight :: SwitchSubscribed x a -> IO Height

22652271calculateSwitchHeight subscribed = getEventSubscribedHeight . _eventSubscription_subscribed =<< readIORef (switchSubscribedCurrentParent subscribed)