b24a09b · patch · git.iko.soy

reflex.cabal+1−1

compare with develop

unifiedsplit

@@ -111,7 +111,7 @@ library

111 Reflex.Widget.Basic,

112 Reflex.Workflow

113

114− ghc-options: -Wall -fwarn-tabs -funbox-strict-fields -O2 -fspecialise-aggressively -ddump-simpl -ddump-to-file -dsuppress-coercions -dsuppress-idinfo

114+ ghc-options: -Wall -fwarn-redundant-constraints -fwarn-tabs -funbox-strict-fields -O2 -fspecialise-aggressively -ddump-simpl -ddump-to-file -dsuppress-coercions -dsuppress-idinfo

115 ghc-prof-options: -fprof-auto

116

117 if flag(debug-trace-events)

src/Data/AppendMap.hs+3−3

@@ -197,7 +197,7 @@ foldlWithKey :: forall k a b. (a -> k -> b -> a) -> a -> MonoidalMap k b -> a

197foldlWithKey = coerce (Map.foldlWithKey :: (a -> k -> b -> a) -> a -> Map k b -> a)

198

199foldMapWithKey :: forall k a m. Monoid m => (k -> a -> m) -> MonoidalMap k a -> m

200−foldMapWithKey = coerce (Map.foldMapWithKey :: Monoid m => (k -> a -> m) -> Map k a -> m)

200+foldMapWithKey = coerce (Map.foldMapWithKey :: (k -> a -> m) -> Map k a -> m)

201

202foldr' :: forall k a b. (a -> b -> b) -> b -> MonoidalMap k a -> b

203foldr' = coerce (Map.foldr' :: (a -> b -> b) -> b -> Map k a -> b)

@@ -350,13 +350,13 @@ maxViewWithKey :: forall k a. MonoidalMap k a -> Maybe ((k, a), MonoidalMap k a)

350maxViewWithKey = coerce (Map.maxViewWithKey :: Map k a -> Maybe ((k, a), Map k a))

351

352showTree :: forall k a. (Show k, Show a) => MonoidalMap k a -> String

353−showTree = coerce (Map.showTree :: (Show k, Show a) => Map k a -> String)

353+showTree = coerce (Map.showTree :: Map k a -> String)

354

355showTreeWith :: forall k a. (k -> a -> String) -> Bool -> Bool -> MonoidalMap k a -> String

356showTreeWith = coerce (Map.showTreeWith :: (k -> a -> String) -> Bool -> Bool -> Map k a -> String)

357

358valid :: forall k a. Ord k => MonoidalMap k a -> Bool

359−valid = coerce (Map.valid :: Ord k => Map k a -> Bool)

359+valid = coerce (Map.valid :: Map k a -> Bool)

360

361instance Default (MonoidalMap k a) where

362 def = empty

src/Reflex/Class.hs+3−3

@@ -561,13 +561,13 @@ attachWithMaybe f b e = flip push e $ \o -> (`f` o) <$> sample b

561

562-- | Create a new 'Event' that occurs on all but the first occurence of the

563-- supplied 'Event'.

564−tailE :: (Reflex t, MonadHold t m, MonadFix m) => Event t a -> m (Event t a)

564+tailE :: (Reflex t, MonadHold t m) => Event t a -> m (Event t a)

565tailE e = snd <$> headTailE e

566

567-- | Create a tuple of two 'Event's with the first one occuring only the first

568-- time the supplied 'Event' occurs and the second occuring on all but the first

569-- occurence.

570−headTailE :: (Reflex t, MonadHold t m, MonadFix m) => Event t a -> m (Event t a, Event t a)

570+headTailE :: (Reflex t, MonadHold t m) => Event t a -> m (Event t a, Event t a)

571headTailE e = do

572 eHead <- headE e

573 be <- hold never $ fmap (const e) eHead

@@ -1162,7 +1162,7 @@ appendEvents = alignWith $ mergeThese mappend

1162

1163-- | Alias for 'headE'

1164{-# DEPRECATED onceE "Use 'headE' instead" #-}

1165−onceE :: (Reflex t, MonadHold t m, MonadFix m) => Event t a -> m (Event t a)

1165+onceE :: MonadHold t m => Event t a -> m (Event t a)

1166onceE = headE

1167

1168-- | Run both sides of a 'These' monadically, combining the results.

src/Reflex/EventWriter/Base.hs+6−6

@@ -161,7 +161,7 @@ runWithReplaceEventWriterTWith f a0 a' = do

161 return (fst result0, fmapCheap fst result')

162

163-- | Like 'runWithReplaceEventWriterTWith', but for 'sequenceIntMapWithAdjust'.

164−sequenceIntMapWithAdjustEventWriterTWith :: forall t m p w v v'. (Reflex t, MonadHold t m, Semigroup w, Semigroup w, Functor p, Patch (p (Event t w)), PatchTarget (p (Event t w)) ~ IntMap (Event t w))

164+sequenceIntMapWithAdjustEventWriterTWith :: forall t m p w v v'. (Reflex t, MonadHold t m, Semigroup w, Functor p, Patch (p (Event t w)), PatchTarget (p (Event t w)) ~ IntMap (Event t w))

165 => ( (IntMap.Key -> v -> m (Event t w, v'))

166 -> IntMap v

167 -> Event t (p v)

@@ -269,7 +269,7 @@ instance (MonadQuery t q m, Monad m) => MonadQuery t q (EventWriterT t w m) wher

269 queryIncremental = lift . queryIncremental

270

271-- | Map a function over the output of a 'EventWriterT'.

272−withEventWriterT :: (Semigroup w, Semigroup w', Reflex t, MonadHold t m, MonadFix m)

272+withEventWriterT :: (Semigroup w, Semigroup w', Reflex t, MonadHold t m)

273 => (w -> w')

274 -> EventWriterT t w m a

275 -> EventWriterT t w' m a

@@ -282,8 +282,8 @@ withEventWriterT f ew = do

282 return r

283

284-- | Change the monad underlying an EventWriterT

285−mapEventWriterT :: (Semigroup w, Reflex t, MonadHold t m, MonadFix m)

285+mapEventWriterT

286− => (forall x. m x -> n x)

286+ :: (forall x. m x -> n x)

287− -> EventWriterT t w m a

287+ -> EventWriterT t w m a

288− -> EventWriterT t w n a

288+ -> EventWriterT t w n a

289mapEventWriterT f (EventWriterT a) = EventWriterT $ mapStateT f a

src/Reflex/Network.hs+3−3

@@ -16,7 +16,7 @@ import Reflex.PostBuild.Class

16-- | Given a Dynamic of network-creating actions, create a network that is recreated whenever the Dynamic updates.

17-- The returned Event of network results occurs when the Dynamic does.

18-- Note: Often, the type 'a' is an Event, in which case the return value is an Event-of-Events that would typically be flattened (via 'switchPromptly').

19−networkView :: (Reflex t, NotReady t m, Adjustable t m, PostBuild t m) => Dynamic t (m a) -> m (Event t a)

19+networkView :: (NotReady t m, Adjustable t m, PostBuild t m) => Dynamic t (m a) -> m (Event t a)

20networkView child = do

21 postBuild <- getPostBuild

22 let newChild = leftmost [updated child, tagCheap (current child) postBuild]

@@ -25,14 +25,14 @@ networkView child = do

25-- | Given an initial network and an Event of network-creating actions, create a network that is recreated whenever the Event fires.

26-- The returned Dynamic of network results occurs when the Event does.

27-- Note: Often, the type 'a' is an Event, in which case the return value is a Dynamic-of-Events that would typically be flattened.

28−networkHold :: (Reflex t, Adjustable t m, MonadHold t m) => m a -> Event t (m a) -> m (Dynamic t a)

28+networkHold :: (Adjustable t m, MonadHold t m) => m a -> Event t (m a) -> m (Dynamic t a)

29networkHold child0 newChild = do

30 (result0, newResult) <- runWithReplace child0 newChild

31 holdDyn result0 newResult

32

33-- | Render a placeholder network to be shown while another network is not yet

34-- done building

35−untilReady :: (Reflex t, Adjustable t m, PostBuild t m) => m a -> m b -> m (a, Event t b)

35+untilReady :: (Adjustable t m, PostBuild t m) => m a -> m b -> m (a, Event t b)

36untilReady a b = do

37 postBuild <- getPostBuild

38 runWithReplace a $ b <$ postBuild

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

@@ -70,11 +70,11 @@ data From (k :: a -> *) (v :: a -> *) :: a -> * where

70type To = ComposeMaybe

71

72-- |Test whether a 'PatchDMapWithMove' satisfies its invariants.

73−validPatchDMapWithMove :: forall k v. (GCompare k, GEq k, GShow k) => DMap k (NodeInfo k v) -> Bool

73+validPatchDMapWithMove :: forall k v. (GCompare k, GShow k) => DMap k (NodeInfo k v) -> Bool

74validPatchDMapWithMove = not . null . validationErrorsForPatchDMapWithMove

75

76-- |Enumerate what reasons a 'PatchDMapWithMove' doesn't satisfy its invariants, returning @[]@ if it's valid.

77−validationErrorsForPatchDMapWithMove :: forall k v. (GCompare k, GEq k, GShow k) => DMap k (NodeInfo k v) -> [String]

77+validationErrorsForPatchDMapWithMove :: forall k v. (GCompare k, GShow k) => DMap k (NodeInfo k v) -> [String]

78validationErrorsForPatchDMapWithMove m =

79 noSelfMoves <> movesBalanced

80 where

@@ -268,7 +268,7 @@ unsafePatchDMapWithMove = PatchDMapWithMove

268

269-- |Wrap a 'DMap' representing patch changes into a 'PatchDMapWithMove' while checking invariants. If the invariants are satisfied, @Right p@ is returned

270-- otherwise @Left errors@.

271−patchDMapWithMove :: (GCompare k, GEq k, GShow k) => DMap k (NodeInfo k v) -> Either [String] (PatchDMapWithMove k v)

271+patchDMapWithMove :: (GCompare k, GShow k) => DMap k (NodeInfo k v) -> Either [String] (PatchDMapWithMove k v)

272patchDMapWithMove dm =

273 case validationErrorsForPatchDMapWithMove dm of

274 [] -> Right $ unsafePatchDMapWithMove dm

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

@@ -60,14 +60,14 @@ deriving instance ReflexHost t => Monad (PerformEventT t m)

60deriving instance ReflexHost t => MonadFix (PerformEventT t m)

61deriving instance (ReflexHost t, MonadIO (HostFrame t)) => MonadIO (PerformEventT t m)

62deriving instance (ReflexHost t, MonadException (HostFrame t)) => MonadException (PerformEventT t m)

63−deriving instance (ReflexHost t, Applicative m, Monoid a) => Monoid (PerformEventT t m a)

63+deriving instance (ReflexHost t, Monoid a) => Monoid (PerformEventT t m a)

64−deriving instance (ReflexHost t, Applicative m, S.Semigroup a) => S.Semigroup (PerformEventT t m a)

64+deriving instance (ReflexHost t, S.Semigroup a) => S.Semigroup (PerformEventT t m a)

65

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

67 type PrimState (PerformEventT t m) = PrimState (HostFrame t)

68 primitive = PerformEventT . lift . primitive

69

70−instance (ReflexHost t, Ref m ~ Ref IO, PrimMonad (HostFrame t)) => PerformEvent t (PerformEventT t m) where

70+instance (ReflexHost t, Ref m ~ Ref IO) => PerformEvent t (PerformEventT t m) where

71 type Performable (PerformEventT t m) = HostFrame t

72 {-# INLINABLE performEvent_ #-}

73 performEvent_ = PerformEventT . requesting_

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

@@ -280,7 +280,7 @@ tagRequest req = do

280 return t

281

282{-# INLINE responseFromTag #-}

283−responseFromTag :: (Monad m, Reflex t) => MyTagWrap response (Entry response x) -> RequesterT t request response m (Event t (Entry response x))

283+responseFromTag :: Monad m => MyTagWrap response (Entry response x) -> RequesterT t request response m (Event t (Entry response x))

284responseFromTag (MyTagWrap t) = do

285 responses :: EventSelectorInt t Any <- RequesterT ask

286 return $ (unsafeCoerce :: Event t Any -> Event t (Entry response x)) $ selectInt responses t

@@ -315,7 +315,7 @@ instance (Reflex t, Adjustable t m, MonadHold t m, MonadFix m) => Adjustable t (

315 traverseDMapWithKeyWithAdjust = traverseDMapWithKeyWithAdjustRequesterTWith (\f dm0 dm' -> lift $ traverseDMapWithKeyWithAdjust f dm0 dm') mapPatchDMap weakenPatchDMapWith patchMapNewElementsMap mergeMapIncremental

316 traverseDMapWithKeyWithAdjustWithMove = traverseDMapWithKeyWithAdjustRequesterTWith (\f dm0 dm' -> lift $ traverseDMapWithKeyWithAdjustWithMove f dm0 dm') mapPatchDMapWithMove weakenPatchDMapWithMoveWith patchMapWithMoveNewElementsMap mergeMapIncrementalWithMove

317

318−requesting' :: (MyTagTypeOffset x, Monad m, Reflex t) => Event t (Entry request x) -> RequesterT t request response m (Event t (Entry response x))

318+requesting' :: (MyTagTypeOffset x, Monad m) => Event t (Entry request x) -> RequesterT t request response m (Event t (Entry response x))

319requesting' = responseFromTag . castMyTagWrap <=< tagRequest

320

321{-# INLINABLE runWithReplaceRequesterTWith #-}

src/Reflex/Spider/Internal.hs+5−5

@@ -235,7 +235,7 @@ subscribeAndRead = unEvent

235-- caching; if the computation function is very cheap, this is (much) more

236-- efficient than 'push'

237{-# INLINE [1] pushCheap #-}

238−pushCheap :: HasSpiderTimeline x => (a -> ComputeM x (Maybe b)) -> Event x a -> Event x b

238+pushCheap :: (a -> ComputeM x (Maybe b)) -> Event x a -> Event x b

239pushCheap !f e = Event $ \sub -> do

240 (subscription, occ) <- subscribeAndRead e $ sub

241 { subscriberPropagate = \a -> do

@@ -379,7 +379,7 @@ eventSwitch !s = Event $ wrap eventSubscribedSwitch $ getSwitchSubscribed s

379eventCoincidence :: HasSpiderTimeline x => Coincidence x a -> Event x a

380eventCoincidence !c = Event $ wrap eventSubscribedCoincidence $ getCoincidenceSubscribed c

381

382−eventHold :: HasSpiderTimeline x => Hold x p -> Event x p

382+eventHold :: Hold x p -> Event x p

383eventHold !h = Event $ subscribeHoldEvent h

384

385eventDyn :: (HasSpiderTimeline x, Patch p) => Dyn x p -> Event x p

@@ -636,7 +636,7 @@ walkInvalidHeightParents s0 = do

636#endif

637

638{-# INLINE subscribeHoldEvent #-}

639−subscribeHoldEvent :: HasSpiderTimeline x => Hold x p -> Subscriber x p -> EventM x (EventSubscription x, Maybe p)

639+subscribeHoldEvent :: Hold x p -> Subscriber x p -> EventM x (EventSubscription x, Maybe p)

640subscribeHoldEvent = subscribeAndRead . holdEvent

641

642--------------------------------------------------------------------------------

@@ -708,13 +708,13 @@ data Dynamic x p = Dynamic

708 , dynamicUpdated :: !(Event x p)

709 }

710

711−dynamicHold :: HasSpiderTimeline x => Hold x p -> Dynamic x p

711+dynamicHold :: Hold x p -> Dynamic x p

712dynamicHold !h = Dynamic

713 { dynamicCurrent = behaviorHold h

714 , dynamicUpdated = eventHold h

715 }

716

717−dynamicHoldIdentity :: HasSpiderTimeline x => Hold x (Identity a) -> Dynamic x (Identity a)

717+dynamicHoldIdentity :: Hold x (Identity a) -> Dynamic x (Identity a)

718dynamicHoldIdentity = dynamicHold

719

720dynamicConst :: PatchTarget p -> Dynamic x p