b877432 · reflex · git.iko.soy

git.iko.soy/reflex

on develop help sign in

Get rid of sum type for Dynamic

b877432Ryan Trinkle10 years ago

src/Reflex/Spider/Internal.hs+69−71

compare with develop

unifiedsplit

@@ -230,12 +230,6 @@ eventHold !h = Event $ subscribeHoldEvent h

230eventDyn :: (a ~ p b, R.Patch p) => Dyn x p b -> Event x a

231eventDyn !j = Event $ \sub -> getDynHold j >>= \h -> subscribeHoldEvent h sub

232

233−eventHoldIdentity :: (a ~ Identity b) => Hold x Identity b -> Event x a

234−eventHoldIdentity !h = Event $ subscribeHoldEvent h

235−

236−eventDynIdentity :: (a ~ Identity b) => Dyn x Identity b -> Event x a

237−eventDynIdentity !j = Event $ \sub -> getDynHold j >>= \h -> subscribeHoldEvent h sub

238−

239{-# INLINE subscribeCoincidenceInner #-}

233{-# INLINE subscribeCoincidenceInner #-}

240subscribeCoincidenceInner :: CanSubscribe x m => Event x a -> Height -> CoincidenceSubscribed x a -> m (Maybe a, Height, EventSubscribed x a)

234subscribeCoincidenceInner :: CanSubscribe x m => Event x a -> Height -> CoincidenceSubscribed x a -> m (Maybe a, Height, EventSubscribed x a)

241subscribeCoincidenceInner inner outerHeight subscribedUnsafe = do

235subscribeCoincidenceInner inner outerHeight subscribedUnsafe = do

@@ -630,9 +624,6 @@ behaviorPull !p = Behavior $ do

630behaviorDyn :: R.Patch p => Dyn x p a -> Behavior x a

624behaviorDyn :: R.Patch p => Dyn x p a -> Behavior x a

631behaviorDyn !d = Behavior $ readHoldTracked =<< getDynHold d

625behaviorDyn !d = Behavior $ readHoldTracked =<< getDynHold d

632

626

633−behaviorDynIdentity :: Dyn x Identity a -> Behavior x a

634−behaviorDynIdentity = behaviorDyn

635−

636{-# INLINE readHoldTracked #-}

627{-# INLINE readHoldTracked #-}

637readHoldTracked :: Hold x p a -> BehaviorM x a

628readHoldTracked :: Hold x p a -> BehaviorM x a

638readHoldTracked h = do

629readHoldTracked h = do

@@ -648,6 +639,39 @@ readBehaviorUntracked b = do

648 holdInits <- getDeferralQueue

639 holdInits <- getDeferralQueue

649 liftIO $ runBehaviorM (readBehaviorTracked b) Nothing holdInits --TODO: Specialize readBehaviorTracked to the Nothing and Just cases

640 liftIO $ runBehaviorM (readBehaviorTracked b) Nothing holdInits --TODO: Specialize readBehaviorTracked to the Nothing and Just cases

650

641

642+--------------------------------------------------------------------------------

643+-- Dynamic

644+--------------------------------------------------------------------------------

645+

646+data Dynamic x p a = Dynamic

647+ { dynamicCurrent :: !(Behavior x a)

648+ , dynamicUpdated :: !(Event x (p a))

649+ }

650+

651+dynamicHold :: Hold x p a -> Dynamic x p a

652+dynamicHold !h = Dynamic

653+ { dynamicCurrent = behaviorHold h

654+ , dynamicUpdated = eventHold h

655+ }

656+

657+dynamicHoldIdentity :: Hold x Identity a -> Dynamic x Identity a

658+dynamicHoldIdentity = dynamicHold

659+

660+dynamicConst :: a -> Dynamic x p a

661+dynamicConst !a = Dynamic

662+ { dynamicCurrent = behaviorConst a

663+ , dynamicUpdated = eventNever

664+ }

665+

666+dynamicDyn :: R.Patch p => Dyn x p a -> Dynamic x p a

667+dynamicDyn !d = Dynamic

668+ { dynamicCurrent = behaviorDyn d

669+ , dynamicUpdated = eventDyn d

670+ }

671+

672+dynamicDynIdentity :: Dyn x Identity a -> Dynamic x Identity a

673+dynamicDynIdentity = dynamicDyn

674+

651--------------------------------------------------------------------------------

675--------------------------------------------------------------------------------

652-- Combinators

676-- Combinators

653--------------------------------------------------------------------------------

677--------------------------------------------------------------------------------

@@ -1049,89 +1073,63 @@ newInvalidatorSwitch subd = return $! InvalidatorSwitch subd

1049newInvalidatorPull :: Pull x a -> IO (Invalidator x)

1073newInvalidatorPull :: Pull x a -> IO (Invalidator x)

1050newInvalidatorPull p = return $! InvalidatorPull p

1074newInvalidatorPull p = return $! InvalidatorPull p

1051

1075

1052−data Dynamic x p a

1076+instance R.FunctorMaybe (Event x) where

1053− = DynamicHold !(Hold x p a)

1077+ fmapMaybe f = push $ return . f

1054− | p ~ Identity => DynamicHoldIdentity !(Hold x Identity a)

1078+

1055− | DynamicConst !a

1079+instance Align (Event x) where

1056− | DynamicDyn !(Dyn x p a)

1057− | p ~ Identity => DynamicDynIdentity !(Dyn x Identity a)

1058−

1059−{-# INLINE current #-}

1060−current :: R.Patch p => Dynamic x p a -> Behavior x a

1061−current = \case

1062− DynamicHold h -> behaviorHold h

1063− DynamicHoldIdentity h -> behaviorHoldIdentity h

1064− DynamicConst a -> behaviorConst a

1065− DynamicDyn d -> behaviorDyn d

1066− DynamicDynIdentity d -> behaviorDynIdentity d

1067−

1068−--TODO: If you only need updated, not current, can we avoid actually constructing the Hold?

1069−{-# INLINE updated #-}

1070−updated :: R.Patch p => Dynamic x p a -> Event x (p a)

1071−updated = \case

1072− DynamicHold h -> eventHold h

1073− DynamicHoldIdentity h -> eventHoldIdentity h

1074− DynamicConst _ -> eventNever

1080+ nil = eventNever

1075− DynamicDyn d -> eventDyn d

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

1076− DynamicDynIdentity d -> eventDynIdentity d

1082+

1083+newtype Dyn x p a = Dyn { unDyn :: IORef (Either (BehaviorM x a, Event x (p a)) (Hold x p a)) }

1077

1084

1078newMapDyn :: (a -> b) -> Dynamic x Identity a -> Dynamic x Identity b

1085newMapDyn :: (a -> b) -> Dynamic x Identity a -> Dynamic x Identity b

1079−newMapDyn f d = DynamicDynIdentity $ unsafeDyn (fmap f $ readBehaviorTracked $ current d) (Identity . f . runIdentity <$> updated d)

1086+newMapDyn f d = dynamicDynIdentity $ unsafeDyn (fmap f $ readBehaviorTracked $ dynamicCurrent d) (Identity . f . runIdentity <$> dynamicUpdated d)

1080

1087

1081instance Functor (Dynamic x Identity) where

1088instance Functor (Dynamic x Identity) where

1082 fmap = newMapDyn

1089 fmap = newMapDyn

1083

1090

1084instance Applicative (Dynamic x Identity) where

1091instance Applicative (Dynamic x Identity) where

1085− pure = DynamicConst

1092+ pure = dynamicConst

1086 (<*>) = zipDynWith ($)

1093 (<*>) = zipDynWith ($)

1087 _ *> b = b

1094 _ *> b = b

1088 a <* _ = a

1095 a <* _ = a

1089

1096

1090−instance R.FunctorMaybe (Event x) where

1091− fmapMaybe f = push $ return . f

1092−

1093−instance Align (Event x) where

1094− nil = eventNever

1095− align ea eb = R.fmapMaybe R.dmapToThese $ merge $ DynamicConst $ DMap.fromList [R.LeftTag :=> ea, R.RightTag :=> eb]

1096−

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

1098zipDynWith :: (a -> b -> c) -> Dynamic x Identity a -> Dynamic x Identity b -> Dynamic x Identity c

1099zipDynWith f da db =

1100− let eab = align (updated da) (updated db)

1100+ let eab = align (dynamicUpdated da) (dynamicUpdated db)

1101 ec = flip push eab $ \o -> do

1102 (a, b) <- case o of

1103 This (Identity a) -> do

1104− b <- readBehaviorUntracked $ current db

1104+ b <- readBehaviorUntracked $ dynamicCurrent db

1105 return (a, b)

1106 That (Identity b) -> do

1107− a <- readBehaviorUntracked $ current da

1107+ a <- readBehaviorUntracked $ dynamicCurrent da

1108 return (a, b)

1109 These (Identity a) (Identity b) -> return (a, b)

1110 return $ Just $ Identity $ f a b

1111− in DynamicDynIdentity $ unsafeDyn (f <$> readBehaviorUntracked (current da) <*> readBehaviorUntracked (current db)) ec

1111+ in dynamicDynIdentity $ unsafeDyn (f <$> readBehaviorUntracked (dynamicCurrent da) <*> readBehaviorUntracked (dynamicCurrent db)) ec

1112

1113instance Monad (Dynamic x Identity) where

1114 {-# INLINE return #-}

1115 return = pure

1116 {-# INLINE (>>=) #-}

1117− x >>= f = DynamicDynIdentity $ newJoinDyn $ newMapDyn f x

1117+ x >>= f = dynamicDynIdentity $ newJoinDyn $ newMapDyn f x

1118 {-# INLINE (>>) #-}

1119 _ >> y = y

1120 {-# INLINE fail #-}

1121 fail _ = error "Dynamic does not support 'fail'"

1122

1123−newtype Dyn x p a = Dyn { unDyn :: IORef (Either (BehaviorM x a, Event x (p a)) (Hold x p a)) }

1124−

1125unsafeDyn :: BehaviorM x a -> Event x (p a) -> Dyn x p a

1123unsafeDyn :: BehaviorM x a -> Event x (p a) -> Dyn x p a

1126unsafeDyn readV0 v' = Dyn $ unsafeNewIORef x $ Left x

1124unsafeDyn readV0 v' = Dyn $ unsafeNewIORef x $ Left x

1127 where x = (readV0, v')

1125 where x = (readV0, v')

1128

1126

1129newJoinDyn :: Dynamic x Identity (Dynamic x Identity a) -> Dyn x Identity a

1127newJoinDyn :: Dynamic x Identity (Dynamic x Identity a) -> Dyn x Identity a

1130newJoinDyn d =

1128newJoinDyn d =

1131− let readV0 = readBehaviorTracked . current =<< readBehaviorTracked (current d)

1129+ let readV0 = readBehaviorTracked . dynamicCurrent =<< readBehaviorTracked (dynamicCurrent d)

1132− eOuter = push (fmap (Just . Identity) . readBehaviorUntracked . current . runIdentity) $ updated d

1130+ eOuter = push (fmap (Just . Identity) . readBehaviorUntracked . dynamicCurrent . runIdentity) $ dynamicUpdated d

1133− eInner = switch $ updated <$> current d

1131+ eInner = switch $ dynamicUpdated <$> dynamicCurrent d

1134− eBoth = coincidence $ updated . runIdentity <$> updated d

1132+ eBoth = coincidence $ dynamicUpdated . runIdentity <$> dynamicUpdated d

1135 v' = unSpiderEvent $ R.leftmost $ map SpiderEvent [eBoth, eOuter, eInner]

1133 v' = unSpiderEvent $ R.leftmost $ map SpiderEvent [eBoth, eOuter, eInner]

1136 in unsafeDyn readV0 v'

1134 in unsafeDyn readV0 v'

1137

1135

@@ -1473,7 +1471,7 @@ getMergeSubscribed m sub = do

1473 Nothing -> {-# SCC "missMerge" #-} do

1471 Nothing -> {-# SCC "missMerge" #-} do

1474 subscribedRef <- liftIO $ newIORef $ error "getMergeSubscribed: subscribedRef not yet initialized"

1472 subscribedRef <- liftIO $ newIORef $ error "getMergeSubscribed: subscribedRef not yet initialized"

1475 subscribedUnsafe <- liftIO $ unsafeInterleaveIO $ readIORef subscribedRef

1473 subscribedUnsafe <- liftIO $ unsafeInterleaveIO $ readIORef subscribedRef

1476− initialParents <- readBehaviorUntracked $ current $ mergeParents m

1474+ initialParents <- readBehaviorUntracked $ dynamicCurrent $ mergeParents m

1477 subscribers :: [(Maybe (DSum k Identity), Height, DSum k (MergeSubscribedParent x k))] <- forM (DMap.toList initialParents) $ \(k :=> e) -> do

1475 subscribers :: [(Maybe (DSum k Identity), Height, DSum k (MergeSubscribedParent x k))] <- forM (DMap.toList initialParents) $ \(k :=> e) -> do

1478 s <- liftIO $ newSubscriberMerge k subscribedUnsafe

1476 s <- liftIO $ newSubscriberMerge k subscribedUnsafe

1479 (subscription@(EventSubscription _ parentSubd), parentOcc) <- subscribeAndRead e s

1477 (subscription@(EventSubscription _ parentSubd), parentOcc) <- subscribeAndRead e s

@@ -1514,7 +1512,7 @@ getMergeSubscribed m sub = do

1514 , mergeSubscribedNodeId = unsafeNodeId m

1512 , mergeSubscribedNodeId = unsafeNodeId m

1515#endif

1513#endif

1516 }

1514 }

1517− defer $ SomeMergeInit subscribed $ updated $ mergeParents m

1515+ defer $ SomeMergeInit subscribed $ dynamicUpdated $ mergeParents m

1518 liftIO $ writeIORef subscribedRef $! subscribed

1516 liftIO $ writeIORef subscribedRef $! subscribed

1519 liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "MergeSubscribed"

1517 liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "MergeSubscribed"

1520 liftIO $ writeIORef (mergeSubscribed m) $ Just subscribed

1518 liftIO $ writeIORef (mergeSubscribed m) $ Just subscribed

@@ -2032,7 +2030,7 @@ instance R.Reflex (SpiderEnv x) where

2032 {-# INLINABLE pull #-}

2030 {-# INLINABLE pull #-}

2033 pull = SpiderBehavior . pull . coerce

2031 pull = SpiderBehavior . pull . coerce

2034 {-# INLINABLE merge #-}

2032 {-# INLINABLE merge #-}

2035− merge = SpiderEvent . merge . DynamicConst . (coerce :: DMap k (R.Event (SpiderEnv x)) -> DMap k (Event x))

2033+ merge = SpiderEvent . merge . dynamicConst . (coerce :: DMap k (R.Event (SpiderEnv x)) -> DMap k (Event x))

2036 {-# INLINABLE fan #-}

2034 {-# INLINABLE fan #-}

2037 fan e = R.EventSelector $ SpiderEvent . select (fan (unSpiderEvent e))

2035 fan e = R.EventSelector $ SpiderEvent . select (fan (unSpiderEvent e))

2038 {-# INLINABLE switch #-}

2036 {-# INLINABLE switch #-}

@@ -2040,22 +2038,22 @@ instance R.Reflex (SpiderEnv x) where

2040 {-# INLINABLE coincidence #-}

2038 {-# INLINABLE coincidence #-}

2041 coincidence = SpiderEvent . coincidence . (coerce :: Event x (R.Event (SpiderEnv x) a) -> Event x (Event x a)) . unSpiderEvent

2039 coincidence = SpiderEvent . coincidence . (coerce :: Event x (R.Event (SpiderEnv x) a) -> Event x (Event x a)) . unSpiderEvent

2042 {-# INLINABLE current #-}

2040 {-# INLINABLE current #-}

2043− current = SpiderBehavior . current . unSpiderDynamic

2041+ current = SpiderBehavior . dynamicCurrent . unSpiderDynamic

2044 {-# INLINABLE updated #-}

2042 {-# INLINABLE updated #-}

2045− updated = SpiderEvent . fmap runIdentity . updated . unSpiderDynamic

2043+ updated = SpiderEvent . fmap runIdentity . dynamicUpdated . unSpiderDynamic

2046 {-# INLINABLE unsafeBuildDynamic #-}

2044 {-# INLINABLE unsafeBuildDynamic #-}

2047− unsafeBuildDynamic readV0 v' = SpiderDynamic $ DynamicDynIdentity $ unsafeDyn (coerce readV0) $ coerce $ unSpiderEvent v'

2045+ unsafeBuildDynamic readV0 v' = SpiderDynamic $ dynamicDynIdentity $ unsafeDyn (coerce readV0) $ coerce $ unSpiderEvent v'

2048 {-# INLINABLE unsafeBuildIncremental #-}

2046 {-# INLINABLE unsafeBuildIncremental #-}

2049− unsafeBuildIncremental readV0 dv = SpiderIncremental $ DynamicDyn $ unsafeDyn (coerce readV0) $ unSpiderEvent dv

2047+ unsafeBuildIncremental readV0 dv = SpiderIncremental $ dynamicDyn $ unsafeDyn (coerce readV0) $ unSpiderEvent dv

2050 {-# INLINABLE mergeIncremental #-}

2048 {-# INLINABLE mergeIncremental #-}

2051 mergeIncremental = SpiderEvent . merge . (unsafeCoerce :: Dynamic x R.PatchDMap (DMap k (R.Event (SpiderEnv x))) -> Dynamic x R.PatchDMap (DMap k (Event x))) . unSpiderIncremental

2049 mergeIncremental = SpiderEvent . merge . (unsafeCoerce :: Dynamic x R.PatchDMap (DMap k (R.Event (SpiderEnv x))) -> Dynamic x R.PatchDMap (DMap k (Event x))) . unSpiderIncremental

2052 {-# INLINABLE currentIncremental #-}

2050 {-# INLINABLE currentIncremental #-}

2053− currentIncremental = SpiderBehavior . current . unSpiderIncremental

2051+ currentIncremental = SpiderBehavior . dynamicCurrent . unSpiderIncremental

2054 {-# INLINABLE updatedIncremental #-}

2052 {-# INLINABLE updatedIncremental #-}

2055− updatedIncremental = SpiderEvent . updated . unSpiderIncremental

2053+ updatedIncremental = SpiderEvent . dynamicUpdated . unSpiderIncremental

2056 {-# INLINABLE incrementalToDynamic #-}

2054 {-# INLINABLE incrementalToDynamic #-}

2057− incrementalToDynamic (SpiderIncremental i) = SpiderDynamic $ DynamicDynIdentity $ unsafeDyn (readBehaviorUntracked $ current i) $ flip push (updated i) $ \p -> do

2055+ incrementalToDynamic (SpiderIncremental i) = SpiderDynamic $ dynamicDynIdentity $ unsafeDyn (readBehaviorUntracked $ dynamicCurrent i) $ flip push (dynamicUpdated i) $ \p -> do

2058− c <- readBehaviorUntracked $ current i

2056+ c <- readBehaviorUntracked $ dynamicCurrent i

2059 return $ Identity <$> R.apply p c --TODO: Avoid the redundant 'apply'

2057 return $ Identity <$> R.apply p c --TODO: Avoid the redundant 'apply'

2060

2058

2061instance R.MonadSample (SpiderEnv x) (EventM x) where

2059instance R.MonadSample (SpiderEnv x) (EventM x) where

@@ -2074,10 +2072,10 @@ holdSpiderEventM :: a -> R.Event (SpiderEnv x) a -> EventM x (R.Behavior (Spider

2074holdSpiderEventM v0 e = fmap (SpiderBehavior . behaviorHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2072holdSpiderEventM v0 e = fmap (SpiderBehavior . behaviorHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2075

2073

2076holdDynSpiderEventM :: a -> R.Event (SpiderEnv x) a -> EventM x (R.Dynamic (SpiderEnv x) a)

2074holdDynSpiderEventM :: a -> R.Event (SpiderEnv x) a -> EventM x (R.Dynamic (SpiderEnv x) a)

2077−holdDynSpiderEventM v0 e = fmap (SpiderDynamic . DynamicHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2075+holdDynSpiderEventM v0 e = fmap (SpiderDynamic . dynamicHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2078

2076

2079holdIncrementalSpiderEventM :: R.Patch p => a -> R.Event (SpiderEnv x) (p a) -> EventM x (R.Incremental (SpiderEnv x) p a)

2077holdIncrementalSpiderEventM :: R.Patch p => a -> R.Event (SpiderEnv x) (p a) -> EventM x (R.Incremental (SpiderEnv x) p a)

2080−holdIncrementalSpiderEventM v0 e = fmap (SpiderIncremental . DynamicHold) $ hold v0 $ unSpiderEvent e

2078+holdIncrementalSpiderEventM v0 e = fmap (SpiderIncremental . dynamicHold) $ hold v0 $ unSpiderEvent e

2081

2079

2082instance R.MonadHold (SpiderEnv x) (SpiderHost x) where

2080instance R.MonadHold (SpiderEnv x) (SpiderHost x) where

2083 {-# INLINABLE hold #-}

2081 {-# INLINABLE hold #-}

@@ -2103,9 +2101,9 @@ instance R.MonadHold (SpiderEnv x) (SpiderPushM x) where

2103 {-# INLINABLE hold #-}

2101 {-# INLINABLE hold #-}

2104 hold v0 e = R.current <$> R.holdDyn v0 e

2102 hold v0 e = R.current <$> R.holdDyn v0 e

2105 {-# INLINABLE holdDyn #-}

2103 {-# INLINABLE holdDyn #-}

2106− holdDyn v0 (SpiderEvent e) = SpiderPushM $ fmap (SpiderDynamic . DynamicHoldIdentity) $ hold v0 $ coerce e

2104+ holdDyn v0 (SpiderEvent e) = SpiderPushM $ fmap (SpiderDynamic . dynamicHoldIdentity) $ hold v0 $ coerce e

2107 {-# INLINABLE holdIncremental #-}

2105 {-# INLINABLE holdIncremental #-}

2108− holdIncremental v0 (SpiderEvent e) = SpiderPushM $ SpiderIncremental . DynamicHold <$> hold v0 e

2106+ holdIncremental v0 (SpiderEvent e) = SpiderPushM $ SpiderIncremental . dynamicHold <$> hold v0 e

2109

2107

2110data RootTrigger x a = forall k. GCompare k => RootTrigger (WeakBag (Subscriber x a), IORef (DMap k Identity), k a)

2108data RootTrigger x a = forall k. GCompare k => RootTrigger (WeakBag (Subscriber x a), IORef (DMap k Identity), k a)

2111

2109

@@ -2193,9 +2191,9 @@ instance R.MonadHold (SpiderEnv x) (SpiderHostFrame x) where

2193 {-# INLINABLE hold #-}

2191 {-# INLINABLE hold #-}

2194 hold v0 e = SpiderHostFrame $ fmap (SpiderBehavior . behaviorHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2192 hold v0 e = SpiderHostFrame $ fmap (SpiderBehavior . behaviorHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2195 {-# INLINABLE holdDyn #-}

2193 {-# INLINABLE holdDyn #-}

2196− holdDyn v0 e = SpiderHostFrame $ fmap (SpiderDynamic . DynamicHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2194+ holdDyn v0 e = SpiderHostFrame $ fmap (SpiderDynamic . dynamicHoldIdentity) $ hold v0 $ coerce $ unSpiderEvent e

2197 {-# INLINABLE holdIncremental #-}

2195 {-# INLINABLE holdIncremental #-}

2198− holdIncremental v0 e = SpiderHostFrame $ fmap (SpiderIncremental . DynamicHold) $ hold v0 $ unSpiderEvent e

2196+ holdIncremental v0 e = SpiderHostFrame $ fmap (SpiderIncremental . dynamicHold) $ hold v0 $ unSpiderEvent e

2199

2197

2200newEventWithTriggerIO :: (RootTrigger x a -> IO (IO ())) -> IO (Event x a)

2198newEventWithTriggerIO :: (RootTrigger x a -> IO (IO ())) -> IO (Event x a)

2201newEventWithTriggerIO f = do

2199newEventWithTriggerIO f = do