cbe4381 · reflex · git.iko.soy

git.iko.soy/reflex

Merge remote-tracking branch 'origin/develop' into fast-weak-partial-requester

commitcbe4381974d70b3d9b00a83572f5c4f887299ca7 authorRyan Trinkle <ryan.trinkle@gmail.com> dateThu 3 Aug 2017, 14:06 (9 years ago) parent37dc4de e39bd39

6 files changed+211−160

compare with develop

unifiedsplit

reflex.cabal+7−4 src/Data/AppendMap.hs+151−152 src/Data/Functor/Misc.hs+6−1 src/Reflex/EventWriter.hs+2−2 src/Reflex/Spider/Internal.hs+3−1 src/Reflex/Widget/Basic.hs+42

reflex.cabal+7−4

@@ -64,7 +64,7 @@ library

6464 semigroupoids >= 4.0 && < 6,

6565 semigroups >= 0.16 && < 0.19,

6666 stm == 2.4.*,

67− syb >= 0.5 && < 0.7,

67+ syb >= 0.5 && < 0.8,

6868 these >= 0.4 && < 0.8,

6969 transformers >= 0.2,

7070 transformers-compat >= 0.3

@@ -101,7 +101,8 @@ library

101101 Reflex.Requester.Base,

102102 Reflex.Requester.Class,

103103 Reflex.Spider,

104− Reflex.Spider.Internal

104+ Reflex.Spider.Internal,

105+ Reflex.Widget.Basic

105106

106107 ghc-options: -Wall -fwarn-tabs -funbox-strict-fields -O2

107108 ghc-prof-options: -fprof-auto

@@ -125,8 +126,8 @@ library

125126 build-depends:

126127 dependent-sum >= 0.3 && < 0.5,

127128 haskell-src-exts >= 1.16 && < 1.19,

128− haskell-src-meta >= 0.6 && < 0.8,

129− template-haskell >= 2.9 && < 2.12

129+ haskell-src-meta >= 0.6 && < 0.9,

130+ template-haskell >= 2.9 && < 2.13

130131 exposed-modules:

131132 Reflex.Dynamic.TH

132133 other-extensions: TemplateHaskell

@@ -244,6 +245,8 @@ test-suite GC-Semantics

244245 , transformers

245246 , reflex

246247 , ref-tf

248+ if impl(ghc < 8)

249+ build-depends: semigroups

247250

248251test-suite rootCleanup

249252 type: exitcode-stdio-1.0

src/Data/AppendMap.hs+151−152

@@ -7,7 +7,6 @@

77{-# LANGUAGE MultiParamTypeClasses #-}

88{-# LANGUAGE RoleAnnotations #-}

99{-# LANGUAGE ScopedTypeVariables #-}

10−{-# LANGUAGE TypeApplications #-}

1110{-# LANGUAGE TypeFamilies #-}

1211-- | 'Data.Map' with a better 'Monoid' instance

1312--

@@ -86,108 +85,108 @@ instance (Ord k, Group q) => Group (AppendMap k q) where

8685instance (Ord k, Additive q) => Additive (AppendMap k q)

8786

8887(!) :: forall k a. Ord k => AppendMap k a -> k -> a

89−(!) = coerce ((Map.!) @k @a)

88+(!) = coerce ((Map.!) :: Map k a -> k -> a)

9089infixl 9 !

9190

9291(\\) :: forall k a b. Ord k => AppendMap k a -> AppendMap k b -> AppendMap k a

93−(\\) = coerce ((Map.\\) @k @a @b)

92+(\\) = coerce ((Map.\\) :: Map k a -> Map k b -> Map k a)

9493infixl 9 \\

9594

9695null :: forall k a. AppendMap k a -> Bool

97−null = coerce (Map.null @k @a)

96+null = coerce (Map.null :: Map k a -> Bool)

9897

9998size :: forall k a. AppendMap k a -> Int

100−size = coerce (Map.size @k @a)

99+size = coerce (Map.size :: Map k a -> Int)

101100

102101member :: forall k a. Ord k => k -> AppendMap k a -> Bool

103−member = coerce (Map.member @k @a)

102+member = coerce (Map.member :: k -> Map k a -> Bool)

104103

105104notMember :: forall k a. Ord k => k -> AppendMap k a -> Bool

106−notMember = coerce (Map.notMember @k @a)

105+notMember = coerce (Map.notMember :: k -> Map k a -> Bool)

107106

108107lookup :: forall k a. Ord k => k -> AppendMap k a -> Maybe a

109−lookup = coerce (Map.lookup @k @a)

108+lookup = coerce (Map.lookup :: k -> Map k a -> Maybe a)

110109

111110findWithDefault :: forall k a. Ord k => a -> k -> AppendMap k a -> a

112−findWithDefault = coerce (Map.findWithDefault @k @a)

111+findWithDefault = coerce (Map.findWithDefault :: a -> k -> Map k a -> a)

113112

114113lookupLT :: forall k a. Ord k => k -> AppendMap k a -> Maybe (k, a)

115−lookupLT = coerce (Map.lookupLT @k @a)

114+lookupLT = coerce (Map.lookupLT :: k -> Map k a -> Maybe (k,a))

116115

117116lookupGT :: forall k a. Ord k => k -> AppendMap k a -> Maybe (k, a)

118−lookupGT = coerce (Map.lookupGT @k @a)

117+lookupGT = coerce (Map.lookupGT :: k -> Map k a -> Maybe (k,a))

119118

120119lookupLE :: forall k a. Ord k => k -> AppendMap k a -> Maybe (k, a)

121−lookupLE = coerce (Map.lookupLE @k @a)

120+lookupLE = coerce (Map.lookupLE :: k -> Map k a -> Maybe (k,a))

122121

123122lookupGE :: forall k a. Ord k => k -> AppendMap k a -> Maybe (k, a)

124−lookupGE = coerce (Map.lookupGE @k @a)

123+lookupGE = coerce (Map.lookupGE :: k -> Map k a -> Maybe (k,a))

125124

126125empty :: forall k a. AppendMap k a

127−empty = coerce (Map.empty @k @a)

126+empty = coerce (Map.empty :: Map k a)

128127

129128singleton :: forall k a. k -> a -> AppendMap k a

130−singleton = coerce (Map.singleton @k @a)

129+singleton = coerce (Map.singleton :: k -> a -> Map k a)

131130

132131insert :: forall k a. Ord k => k -> a -> AppendMap k a -> AppendMap k a

133−insert = coerce (Map.insert @k @a)

132+insert = coerce (Map.insert :: k -> a -> Map k a -> Map k a)

134133

135−insertWith :: Ord k => (a -> a -> a) -> k -> a -> AppendMap k a -> AppendMap k a

136−insertWith f = coerce (Map.insertWith f)

134+insertWith :: forall k a. Ord k => (a -> a -> a) -> k -> a -> AppendMap k a -> AppendMap k a

135+insertWith = coerce (Map.insertWith :: (a -> a -> a) -> k -> a -> Map k a -> Map k a)

137136

138−insertWithKey :: Ord k => (k -> a -> a -> a) -> k -> a -> AppendMap k a -> AppendMap k a

139−insertWithKey f = coerce (Map.insertWithKey f)

137+insertWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> k -> a -> AppendMap k a -> AppendMap k a

138+insertWithKey = coerce (Map.insertWithKey :: (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a)

140139

141−insertLookupWithKey :: Ord k => (k -> a -> a -> a) -> k -> a -> AppendMap k a -> (Maybe a, AppendMap k a)

142−insertLookupWithKey f = coerce (Map.insertLookupWithKey f)

140+insertLookupWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> k -> a -> AppendMap k a -> (Maybe a, AppendMap k a)

141+insertLookupWithKey = coerce (Map.insertLookupWithKey :: (k -> a -> a -> a) -> k -> a -> Map k a -> (Maybe a, Map k a))

143142

144143delete :: forall k a. Ord k => k -> AppendMap k a -> AppendMap k a

145−delete = coerce (Map.delete @k @a)

144+delete = coerce (Map.delete :: k -> Map k a -> Map k a)

146145

147−adjust :: Ord k => (a -> a) -> k -> AppendMap k a -> AppendMap k a

148−adjust f = coerce (Map.adjust f)

146+adjust :: forall k a. Ord k => (a -> a) -> k -> AppendMap k a -> AppendMap k a

147+adjust = coerce (Map.adjust :: (a -> a) -> k -> Map k a -> Map k a)

149148

150−adjustWithKey :: Ord k => (k -> a -> a) -> k -> AppendMap k a -> AppendMap k a

151−adjustWithKey f = coerce (Map.adjustWithKey f)

149+adjustWithKey :: forall k a. Ord k => (k -> a -> a) -> k -> AppendMap k a -> AppendMap k a

150+adjustWithKey = coerce (Map.adjustWithKey :: (k -> a -> a) -> k -> Map k a -> Map k a)

152151

153−update :: Ord k => (a -> Maybe a) -> k -> AppendMap k a -> AppendMap k a

154−update f = coerce (Map.update f)

152+update :: forall k a. Ord k => (a -> Maybe a) -> k -> AppendMap k a -> AppendMap k a

153+update = coerce (Map.update :: (a -> Maybe a) -> k -> Map k a -> Map k a)

155154

156−updateWithKey :: Ord k => (k -> a -> Maybe a) -> k -> AppendMap k a -> AppendMap k a

157−updateWithKey f = coerce (Map.updateWithKey f)

155+updateWithKey :: forall k a. Ord k => (k -> a -> Maybe a) -> k -> AppendMap k a -> AppendMap k a

156+updateWithKey = coerce (Map.updateWithKey :: (k -> a -> Maybe a) -> k -> Map k a -> Map k a)

158157

159−updateLookupWithKey :: Ord k => (k -> a -> Maybe a) -> k -> AppendMap k a -> (Maybe a, AppendMap k a)

160−updateLookupWithKey f = coerce (Map.updateLookupWithKey f)

158+updateLookupWithKey :: forall k a. Ord k => (k -> a -> Maybe a) -> k -> AppendMap k a -> (Maybe a, AppendMap k a)

159+updateLookupWithKey = coerce (Map.updateLookupWithKey :: (k -> a -> Maybe a) -> k -> Map k a -> (Maybe a, Map k a))

161160

162−alter :: Ord k => (Maybe a -> Maybe a) -> k -> AppendMap k a -> AppendMap k a

163−alter f = coerce (Map.alter f)

161+alter :: forall k a. Ord k => (Maybe a -> Maybe a) -> k -> AppendMap k a -> AppendMap k a

162+alter = coerce (Map.alter :: (Maybe a -> Maybe a) -> k -> Map k a -> Map k a)

164163

165−unionWith :: Ord k => (a -> a -> a) -> AppendMap k a -> AppendMap k a -> AppendMap k a

166−unionWith f = coerce (Map.unionWith f)

164+unionWith :: forall k a. Ord k => (a -> a -> a) -> AppendMap k a -> AppendMap k a -> AppendMap k a

165+unionWith = coerce (Map.unionWith :: (a -> a -> a) -> Map k a -> Map k a -> Map k a)

167166

168−unionWithKey :: Ord k => (k -> a -> a -> a) -> AppendMap k a -> AppendMap k a -> AppendMap k a

169−unionWithKey f = coerce (Map.unionWithKey f)

167+unionWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> AppendMap k a -> AppendMap k a -> AppendMap k a

168+unionWithKey = coerce (Map.unionWithKey :: (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a)

170169

171−unionsWith :: Ord k => (a -> a -> a) -> [AppendMap k a] -> AppendMap k a

172−unionsWith f = coerce (Map.unionsWith f)

170+unionsWith :: forall k a. Ord k => (a -> a -> a) -> [AppendMap k a] -> AppendMap k a

171+unionsWith = coerce (Map.unionsWith :: (a -> a -> a) -> [Map k a] -> Map k a)

173172

174−difference :: Ord k => AppendMap k a -> AppendMap k b -> AppendMap k a

173+difference :: forall k a b. Ord k => AppendMap k a -> AppendMap k b -> AppendMap k a

175174difference = (\\)

176175

177−differenceWith :: Ord k => (a -> b -> Maybe a) -> AppendMap k a -> AppendMap k b -> AppendMap k a

178−differenceWith f = coerce (Map.differenceWith f)

176+differenceWith :: forall k a b. Ord k => (a -> b -> Maybe a) -> AppendMap k a -> AppendMap k b -> AppendMap k a

177+differenceWith = coerce (Map.differenceWith :: (a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a)

179178

180−differenceWithKey :: Ord k => (k -> a -> b -> Maybe a) -> AppendMap k a -> AppendMap k b -> AppendMap k a

181−differenceWithKey f = coerce (Map.differenceWithKey f)

179+differenceWithKey :: forall k a b. Ord k => (k -> a -> b -> Maybe a) -> AppendMap k a -> AppendMap k b -> AppendMap k a

180+differenceWithKey = coerce (Map.differenceWithKey :: (k -> a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a)

182181

183−intersectionWith :: Ord k => (a -> b -> c) -> AppendMap k a -> AppendMap k b -> AppendMap k c

184−intersectionWith f = coerce (Map.intersectionWith f)

182+intersectionWith :: forall k a b c. Ord k => (a -> b -> c) -> AppendMap k a -> AppendMap k b -> AppendMap k c

183+intersectionWith = coerce (Map.intersectionWith :: (a -> b -> c) -> Map k a -> Map k b -> Map k c)

185184

186−intersectionWithKey :: Ord k => (k -> a -> b -> c) -> AppendMap k a -> AppendMap k b -> AppendMap k c

187−intersectionWithKey f = coerce (Map.intersectionWithKey f)

185+intersectionWithKey :: forall k a b c. Ord k => (k -> a -> b -> c) -> AppendMap k a -> AppendMap k b -> AppendMap k c

186+intersectionWithKey = coerce (Map.intersectionWithKey :: (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c)

188187

189−mergeWithKey :: Ord k => (k -> a -> b -> Maybe c) -> (AppendMap k a -> AppendMap k c) -> (AppendMap k b -> AppendMap k c) -> AppendMap k a -> AppendMap k b -> AppendMap k c

190−mergeWithKey f = coerce (Map.mergeWithKey f)

188+mergeWithKey :: forall k a b c. Ord k => (k -> a -> b -> Maybe c) -> (AppendMap k a -> AppendMap k c) -> (AppendMap k b -> AppendMap k c) -> AppendMap k a -> AppendMap k b -> AppendMap k c

189+mergeWithKey = coerce (Map.mergeWithKey :: (k -> a -> b -> Maybe c) -> (Map k a -> Map k c) -> (Map k b -> Map k c) -> Map k a -> Map k b -> Map k c)

191190

192191map :: (a -> b) -> AppendMap k a -> AppendMap k b

193192map = fmap

@@ -198,206 +197,206 @@ mapWithKey = imap

198197traverseWithKey :: Applicative t => (k -> a -> t b) -> AppendMap k a -> t (AppendMap k b)

199198traverseWithKey = itraverse

200199

201−mapAccum :: (a -> b -> (a, c)) -> a -> AppendMap k b -> (a, AppendMap k c)

202−mapAccum f = coerce (Map.mapAccum f)

200+mapAccum :: forall k a b c. (a -> b -> (a, c)) -> a -> AppendMap k b -> (a, AppendMap k c)

201+mapAccum = coerce (Map.mapAccum :: (a -> b -> (a, c)) -> a -> Map k b -> (a, Map k c))

203202

204−mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> AppendMap k b -> (a, AppendMap k c)

205−mapAccumWithKey f = coerce (Map.mapAccumWithKey f)

203+mapAccumWithKey :: forall k a b c. (a -> k -> b -> (a, c)) -> a -> AppendMap k b -> (a, AppendMap k c)

204+mapAccumWithKey = coerce (Map.mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c))

206205

207−mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> AppendMap k b -> (a, AppendMap k c)

208−mapAccumRWithKey f = coerce (Map.mapAccumRWithKey f)

206+mapAccumRWithKey :: forall k a b c. (a -> k -> b -> (a, c)) -> a -> AppendMap k b -> (a, AppendMap k c)

207+mapAccumRWithKey = coerce (Map.mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c))

209208

210209mapKeys :: forall k1 k2 a. Ord k2 => (k1 -> k2) -> AppendMap k1 a -> AppendMap k2 a

211−mapKeys = coerce (Map.mapKeys @k2 @k1 @a)

210+mapKeys = coerce (Map.mapKeys :: (k1 -> k2) -> Map k1 a -> Map k2 a)

212211

213−mapKeysWith :: Ord k2 => (a -> a -> a) -> (k1 -> k2) -> AppendMap k1 a -> AppendMap k2 a

214−mapKeysWith f = coerce (Map.mapKeysWith f)

212+mapKeysWith :: forall k1 k2 a. Ord k2 => (a -> a -> a) -> (k1 -> k2) -> AppendMap k1 a -> AppendMap k2 a

213+mapKeysWith = coerce (Map.mapKeysWith :: (a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a)

215214

216215mapKeysMonotonic :: forall k1 k2 a. (k1 -> k2) -> AppendMap k1 a -> AppendMap k2 a

217−mapKeysMonotonic = coerce (Map.mapKeysMonotonic @k1 @k2 @a)

216+mapKeysMonotonic = coerce (Map.mapKeysMonotonic :: (k1 -> k2) -> Map k1 a -> Map k2 a)

218217

219−foldr :: (a -> b -> b) -> b -> AppendMap k a -> b

220−foldr f = coerce (Map.foldr f)

218+foldr :: forall k a b. (a -> b -> b) -> b -> AppendMap k a -> b

219+foldr = coerce (Map.foldr :: (a -> b -> b) -> b -> Map k a -> b)

221220

222−foldl :: (a -> b -> a) -> a -> AppendMap k b -> a

223−foldl f = coerce (Map.foldl f)

221+foldl :: forall k a b. (a -> b -> a) -> a -> AppendMap k b -> a

222+foldl = coerce (Map.foldl :: (a -> b -> a) -> a -> Map k b -> a)

224223

225−foldrWithKey :: (k -> a -> b -> b) -> b -> AppendMap k a -> b

226−foldrWithKey f = coerce (Map.foldrWithKey f)

224+foldrWithKey :: forall k a b. (k -> a -> b -> b) -> b -> AppendMap k a -> b

225+foldrWithKey = coerce (Map.foldrWithKey :: (k -> a -> b -> b) -> b -> Map k a -> b)

227226

228−foldlWithKey :: (a -> k -> b -> a) -> a -> AppendMap k b -> a

229−foldlWithKey f = coerce (Map.foldlWithKey f)

227+foldlWithKey :: forall k a b. (a -> k -> b -> a) -> a -> AppendMap k b -> a

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

230229

231−foldMapWithKey :: Monoid m => (k -> a -> m) -> AppendMap k a -> m

232−foldMapWithKey f = coerce (Map.foldMapWithKey f)

230+foldMapWithKey :: forall k a m. Monoid m => (k -> a -> m) -> AppendMap k a -> m

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

233232

234−foldr' :: (a -> b -> b) -> b -> AppendMap k a -> b

235−foldr' f = coerce (Map.foldr' f)

233+foldr' :: forall k a b. (a -> b -> b) -> b -> AppendMap k a -> b

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

236235

237−foldl' :: (a -> b -> a) -> a -> AppendMap k b -> a

238−foldl' f = coerce (Map.foldl' f)

236+foldl' :: forall k a b. (a -> b -> a) -> a -> AppendMap k b -> a

237+foldl' = coerce (Map.foldl' :: (a -> b -> a) -> a -> Map k b -> a)

239238

240−foldrWithKey' :: (k -> a -> b -> b) -> b -> AppendMap k a -> b

241−foldrWithKey' f = coerce (Map.foldrWithKey' f)

239+foldrWithKey' :: forall k a b. (k -> a -> b -> b) -> b -> AppendMap k a -> b

240+foldrWithKey' = coerce (Map.foldrWithKey' :: (k -> a -> b -> b) -> b -> Map k a -> b)

242241

243−foldlWithKey' :: (a -> k -> b -> a) -> a -> AppendMap k b -> a

244−foldlWithKey' f = coerce (Map.foldlWithKey' f)

242+foldlWithKey' :: forall k a b. (a -> k -> b -> a) -> a -> AppendMap k b -> a

243+foldlWithKey' = coerce (Map.foldlWithKey' :: (a -> k -> b -> a) -> a -> Map k b -> a)

245244

246245elems :: forall k a. AppendMap k a -> [a]

247−elems = coerce (Map.elems @k @a)

246+elems = coerce (Map.elems :: Map k a -> [a])

248247

249248keys :: forall k a. AppendMap k a -> [k]

250−keys = coerce (Map.keys @k @a)

249+keys = coerce (Map.keys :: Map k a -> [k])

251250

252251assocs :: forall k a. AppendMap k a -> [(k, a)]

253−assocs = coerce (Map.assocs @k @a)

252+assocs = coerce (Map.assocs :: Map k a -> [(k, a)])

254253

255254keysSet :: forall k a. AppendMap k a -> Set k

256−keysSet = coerce (Map.keysSet @k @a)

255+keysSet = coerce (Map.keysSet :: Map k a -> Set k)

257256

258−fromSet :: (k -> a) -> Set k -> AppendMap k a

259−fromSet f = coerce (Map.fromSet f)

257+fromSet :: forall k a. (k -> a) -> Set k -> AppendMap k a

258+fromSet = coerce (Map.fromSet :: (k -> a) -> Set k -> Map k a)

260259

261260toList :: forall k a. AppendMap k a -> [(k, a)]

262−toList = coerce (Map.toList @k @a)

261+toList = coerce (Map.toList :: Map k a -> [(k, a)])

263262

264263fromList :: forall k a. Ord k => [(k, a)] -> AppendMap k a

265−fromList = coerce (Map.fromList @k @a)

264+fromList = coerce (Map.fromList :: [(k, a)] -> Map k a)

266265

267−fromListWith :: Ord k => (a -> a -> a) -> [(k, a)] -> AppendMap k a

268−fromListWith f = coerce (Map.fromListWith f)

266+fromListWith :: forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> AppendMap k a

267+fromListWith = coerce (Map.fromListWith :: (a -> a -> a) -> [(k, a)] -> Map k a)

269268

270−fromListWithKey :: Ord k => (k -> a -> a -> a) -> [(k, a)] -> AppendMap k a

271−fromListWithKey f = coerce (Map.fromListWithKey f)

269+fromListWithKey :: forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> AppendMap k a

270+fromListWithKey = coerce (Map.fromListWithKey :: (k -> a -> a -> a) -> [(k, a)] -> Map k a)

272271

273272toAscList :: forall k a. AppendMap k a -> [(k, a)]

274−toAscList = coerce (Map.toAscList @k @a)

273+toAscList = coerce (Map.toAscList :: Map k a -> [(k, a)])

275274

276275toDescList :: forall k a. AppendMap k a -> [(k, a)]

277−toDescList = coerce (Map.toDescList @k @a)

276+toDescList = coerce (Map.toDescList :: Map k a -> [(k, a)])

278277

279278fromAscList :: forall k a. Eq k => [(k, a)] -> AppendMap k a

280−fromAscList = coerce (Map.fromAscList @k @a)

279+fromAscList = coerce (Map.fromAscList :: [(k, a)] -> Map k a)

281280

282−fromAscListWith :: Eq k => (a -> a -> a) -> [(k, a)] -> AppendMap k a

283−fromAscListWith f = coerce (Map.fromAscListWith f)

281+fromAscListWith :: forall k a. Eq k => (a -> a -> a) -> [(k, a)] -> AppendMap k a

282+fromAscListWith = coerce (Map.fromAscListWith :: (a -> a -> a) -> [(k, a)] -> Map k a)

284283

285−fromAscListWithKey :: Eq k => (k -> a -> a -> a) -> [(k, a)] -> AppendMap k a

286−fromAscListWithKey f = coerce (Map.fromAscListWithKey f)

284+fromAscListWithKey :: forall k a. Eq k => (k -> a -> a -> a) -> [(k, a)] -> AppendMap k a

285+fromAscListWithKey = coerce (Map.fromAscListWithKey :: (k -> a -> a -> a) -> [(k, a)] -> Map k a)

287286

288287fromDistinctAscList :: forall k a. [(k, a)] -> AppendMap k a

289−fromDistinctAscList = coerce (Map.fromDistinctAscList @k @a)

288+fromDistinctAscList = coerce (Map.fromDistinctAscList :: [(k, a)] -> Map k a)

290289

291−filter :: (a -> Bool) -> AppendMap k a -> AppendMap k a

292−filter f = coerce (Map.filter f)

290+filter :: forall k a. (a -> Bool) -> AppendMap k a -> AppendMap k a

291+filter = coerce (Map.filter :: (a -> Bool) -> Map k a -> Map k a)

293292

294−filterWithKey :: (k -> a -> Bool) -> AppendMap k a -> AppendMap k a

295−filterWithKey f = coerce (Map.filterWithKey f)

293+filterWithKey :: forall k a. (k -> a -> Bool) -> AppendMap k a -> AppendMap k a

294+filterWithKey = coerce (Map.filterWithKey :: (k -> a -> Bool) -> Map k a -> Map k a)

296295

297−partition :: (a -> Bool) -> AppendMap k a -> (AppendMap k a, AppendMap k a)

298−partition f = coerce (Map.partition f)

296+partition :: forall k a. (a -> Bool) -> AppendMap k a -> (AppendMap k a, AppendMap k a)

297+partition = coerce (Map.partition :: (a -> Bool) -> Map k a -> (Map k a, Map k a))

299298

300−partitionWithKey :: (k -> a -> Bool) -> AppendMap k a -> (AppendMap k a, AppendMap k a)

301−partitionWithKey f = coerce (Map.partitionWithKey f)

299+partitionWithKey :: forall k a. (k -> a -> Bool) -> AppendMap k a -> (AppendMap k a, AppendMap k a)

300+partitionWithKey = coerce (Map.partitionWithKey :: (k -> a -> Bool) -> Map k a -> (Map k a, Map k a))

302301

303−mapMaybe :: (a -> Maybe b) -> AppendMap k a -> AppendMap k b

304−mapMaybe f = coerce (Map.mapMaybe f)

302+mapMaybe :: forall k a b. (a -> Maybe b) -> AppendMap k a -> AppendMap k b

303+mapMaybe = coerce (Map.mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b)

305304

306−mapMaybeWithKey :: (k -> a -> Maybe b) -> AppendMap k a -> AppendMap k b

307−mapMaybeWithKey f = coerce (Map.mapMaybeWithKey f)

305+mapMaybeWithKey :: forall k a b. (k -> a -> Maybe b) -> AppendMap k a -> AppendMap k b

306+mapMaybeWithKey = coerce (Map.mapMaybeWithKey :: (k -> a -> Maybe b) -> Map k a -> Map k b)

308307

309−mapEither :: (a -> Either b c) -> AppendMap k a -> (AppendMap k b, AppendMap k c)

310−mapEither f = coerce (Map.mapEither f)

308+mapEither :: forall k a b c. (a -> Either b c) -> AppendMap k a -> (AppendMap k b, AppendMap k c)

309+mapEither = coerce (Map.mapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c))

311310

312−mapEitherWithKey :: (k -> a -> Either b c) -> AppendMap k a -> (AppendMap k b, AppendMap k c)

313−mapEitherWithKey f = coerce (Map.mapEitherWithKey f)

311+mapEitherWithKey :: forall k a b c. (k -> a -> Either b c) -> AppendMap k a -> (AppendMap k b, AppendMap k c)

312+mapEitherWithKey = coerce (Map.mapEitherWithKey :: (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c))

314313

315314split :: forall k a. Ord k => k -> AppendMap k a -> (AppendMap k a, AppendMap k a)

316−split = coerce (Map.split @k @a)

315+split = coerce (Map.split :: k -> Map k a -> (Map k a, Map k a))

317316

318317splitLookup :: forall k a. Ord k => k -> AppendMap k a -> (AppendMap k a, Maybe a, AppendMap k a)

319−splitLookup = coerce (Map.splitLookup @k @a)

318+splitLookup = coerce (Map.splitLookup :: k -> Map k a -> (Map k a, Maybe a, Map k a))

320319

321320splitRoot :: forall k a. AppendMap k a -> [AppendMap k a]

322−splitRoot = coerce (Map.splitRoot @k @a)

321+splitRoot = coerce (Map.splitRoot :: Map k a -> [Map k a])

323322

324323isSubmapOf :: forall k a. (Ord k, Eq a) => AppendMap k a -> AppendMap k a -> Bool

325−isSubmapOf = coerce (Map.isSubmapOf @k @a)

324+isSubmapOf = coerce (Map.isSubmapOf :: Map k a -> Map k a -> Bool)

326325

327−isSubmapOfBy :: Ord k => (a -> b -> Bool) -> AppendMap k a -> AppendMap k b -> Bool

328−isSubmapOfBy f = coerce (Map.isSubmapOfBy f)

326+isSubmapOfBy :: forall k a b. Ord k => (a -> b -> Bool) -> AppendMap k a -> AppendMap k b -> Bool

327+isSubmapOfBy = coerce (Map.isSubmapOfBy :: (a -> b -> Bool) -> Map k a -> Map k b -> Bool)

329328

330329isProperSubmapOf :: forall k a. (Ord k, Eq a) => AppendMap k a -> AppendMap k a -> Bool

331−isProperSubmapOf = coerce (Map.isProperSubmapOf @k @a)

330+isProperSubmapOf = coerce (Map.isProperSubmapOf :: Map k a -> Map k a -> Bool)

332331

333−isProperSubmapOfBy :: Ord k => (a -> b -> Bool) -> AppendMap k a -> AppendMap k b -> Bool

334−isProperSubmapOfBy f = coerce (Map.isProperSubmapOfBy f)

332+isProperSubmapOfBy :: forall k a b. Ord k => (a -> b -> Bool) -> AppendMap k a -> AppendMap k b -> Bool

333+isProperSubmapOfBy = coerce (Map.isProperSubmapOfBy :: (a -> b -> Bool) -> Map k a -> Map k b -> Bool)

335334

336335lookupIndex :: forall k a. Ord k => k -> AppendMap k a -> Maybe Int

337−lookupIndex = coerce (Map.lookupIndex @k @a)

336+lookupIndex = coerce (Map.lookupIndex :: k -> Map k a -> Maybe Int)

338337

339338findIndex :: forall k a. Ord k => k -> AppendMap k a -> Int

340−findIndex = coerce (Map.findIndex @k @a)

339+findIndex = coerce (Map.findIndex :: k -> Map k a -> Int)

341340

342341elemAt :: forall k a. Int -> AppendMap k a -> (k, a)

343−elemAt = coerce (Map.elemAt @k @a)

342+elemAt = coerce (Map.elemAt :: Int -> Map k a -> (k, a))

344343

345344updateAt :: forall k a. (k -> a -> Maybe a) -> Int -> AppendMap k a -> AppendMap k a

346−updateAt = coerce (Map.updateAt @k @a)

345+updateAt = coerce (Map.updateAt :: (k -> a -> Maybe a) -> Int -> Map k a -> Map k a)

347346

348347deleteAt :: forall k a. Int -> AppendMap k a -> AppendMap k a

349−deleteAt = coerce (Map.deleteAt @k @a)

348+deleteAt = coerce (Map.deleteAt :: Int -> Map k a -> Map k a)

350349

351350findMin :: forall k a. AppendMap k a -> (k, a)

352−findMin = coerce (Map.findMin @k @a)

351+findMin = coerce (Map.findMin :: Map k a -> (k, a))

353352

354353findMax :: forall k a. AppendMap k a -> (k, a)

355−findMax = coerce (Map.findMax @k @a)

354+findMax = coerce (Map.findMax :: Map k a -> (k, a))

356355

357356deleteMin :: forall k a. AppendMap k a -> AppendMap k a

358−deleteMin = coerce (Map.deleteMin @k @ a)

357+deleteMin = coerce (Map.deleteMin :: Map k a -> Map k a)

359358

360359deleteMax :: forall k a. AppendMap k a -> AppendMap k a

361−deleteMax = coerce (Map.deleteMax @k @a)

360+deleteMax = coerce (Map.deleteMax :: Map k a -> Map k a)

362361

363362deleteFindMin :: forall k a. AppendMap k a -> ((k, a), AppendMap k a)

364−deleteFindMin = coerce (Map.deleteFindMin @k @a)

363+deleteFindMin = coerce (Map.deleteFindMin :: Map k a -> ((k, a), Map k a))

365364

366365deleteFindMax :: forall k a. AppendMap k a -> ((k, a), AppendMap k a)

367−deleteFindMax = coerce (Map.deleteFindMax @k @a)

366+deleteFindMax = coerce (Map.deleteFindMax :: Map k a -> ((k, a), Map k a))

368367

369−updateMin :: (a -> Maybe a) -> AppendMap k a -> AppendMap k a

370−updateMin f = coerce (Map.updateMin f)

368+updateMin :: forall k a. (a -> Maybe a) -> AppendMap k a -> AppendMap k a

369+updateMin = coerce (Map.updateMin :: (a -> Maybe a) -> Map k a -> Map k a)

371370

372−updateMax :: (a -> Maybe a) -> AppendMap k a -> AppendMap k a

373−updateMax f = coerce (Map.updateMax f)

371+updateMax :: forall k a. (a -> Maybe a) -> AppendMap k a -> AppendMap k a

372+updateMax = coerce (Map.updateMax :: (a -> Maybe a) -> Map k a -> Map k a)

374373

375−updateMinWithKey :: (k -> a -> Maybe a) -> AppendMap k a -> AppendMap k a

376−updateMinWithKey f = coerce (Map.updateMinWithKey f)

374+updateMinWithKey :: forall k a. (k -> a -> Maybe a) -> AppendMap k a -> AppendMap k a

375+updateMinWithKey = coerce (Map.updateMinWithKey :: (k -> a -> Maybe a) -> Map k a -> Map k a)

377376

378−updateMaxWithKey :: (k -> a -> Maybe a) -> AppendMap k a -> AppendMap k a

379−updateMaxWithKey f = coerce (Map.updateMaxWithKey f)

377+updateMaxWithKey :: forall k a. (k -> a -> Maybe a) -> AppendMap k a -> AppendMap k a

378+updateMaxWithKey = coerce (Map.updateMaxWithKey :: (k -> a -> Maybe a) -> Map k a -> Map k a)

380379

381380minView :: forall k a. AppendMap k a -> Maybe (a, AppendMap k a)

382−minView = coerce (Map.minView @k @a)

381+minView = coerce (Map.minView :: Map k a -> Maybe (a, Map k a))

383382

384383maxView :: forall k a. AppendMap k a -> Maybe (a, AppendMap k a)

385−maxView = coerce (Map.maxView @k @a)

384+maxView = coerce (Map.maxView :: Map k a -> Maybe (a, Map k a))

386385

387386minViewWithKey :: forall k a. AppendMap k a -> Maybe ((k, a), AppendMap k a)

388−minViewWithKey = coerce (Map.minViewWithKey @k @a)

387+minViewWithKey = coerce (Map.minViewWithKey :: Map k a -> Maybe ((k, a), Map k a))

389388

390389maxViewWithKey :: forall k a. AppendMap k a -> Maybe ((k, a), AppendMap k a)

391−maxViewWithKey = coerce (Map.maxViewWithKey @k @a)

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

392391

393392showTree :: forall k a. (Show k, Show a) => AppendMap k a -> String

394−showTree = coerce (Map.showTree @k @a)

393+showTree = coerce (Map.showTree :: (Show k, Show a) => Map k a -> String)

395394

396−showTreeWith :: (k -> a -> String) -> Bool -> Bool -> AppendMap k a -> String

397−showTreeWith f = coerce (Map.showTreeWith f)

395+showTreeWith :: forall k a. (k -> a -> String) -> Bool -> Bool -> AppendMap k a -> String

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

398397

399398valid :: forall k a. Ord k => AppendMap k a -> Bool

400−valid = coerce (Map.valid @k @a)

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

401400

402401instance Default (AppendMap k a) where

403402 def = empty

src/Data/Functor/Misc.hs+6−1

@@ -292,7 +292,12 @@ dsumToEither = \case

292292-- | We can't use @Compose Maybe@ instead of 'ComposeMaybe', because that would

293293-- make the 'f' parameter have a nominal type role. We need f to be

294294-- representational so that we can use safe 'coerce'.

295−newtype ComposeMaybe f a = ComposeMaybe { getComposeMaybe :: Maybe (f a) } deriving (Show, Eq, Ord)

295+#if MIN_VERSION_transformers(5,2,0)

296+newtype ComposeMaybe f a =

297+#else

298+newtype ComposeMaybe (f :: * -> *) (a :: *) =

299+#endif

300+ ComposeMaybe { getComposeMaybe :: Maybe (f a) } deriving (Show, Eq, Ord)

296301

297302deriving instance Functor f => Functor (ComposeMaybe f)

298303

src/Reflex/EventWriter.hs+2−2

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

132132 holdDyn v0 = lift . holdDyn v0

133133 holdIncremental v0 = lift . holdIncremental v0

134134

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

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

136136 runWithReplace = runWithReplaceEventWriterTWith $ \dm0 dm' -> lift $ runWithReplace dm0 dm'

137137 traverseIntMapWithKeyWithAdjust = sequenceIntMapWithAdjustEventWriterTWith (\f dm0 dm' -> lift $ traverseIntMapWithKeyWithAdjust f dm0 dm') patchIntMapNewElements mergeIntIncremental

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

@@ -193,7 +193,7 @@ sequenceIntMapWithAdjustEventWriterTWith base patchNewElements mergePatchIncreme

193193 return (result0, result')

194194

195195-- | Like 'runWithReplaceEventWriterTWith', but for 'sequenceDMapWithAdjust'.

196−sequenceDMapWithAdjustEventWriterTWith :: forall t m p p' w k v v'. (Reflex t, MonadHold t m, Semigroup w, Semigroup w, Patch (p' (Some k) (Event t w)), PatchTarget (p' (Some k) (Event t w)) ~ Map (Some k) (Event t w))

196+sequenceDMapWithAdjustEventWriterTWith :: forall t m p p' w k v v'. (Reflex t, MonadHold t m, Semigroup w, Patch (p' (Some k) (Event t w)), PatchTarget (p' (Some k) (Event t w)) ~ Map (Some k) (Event t w))

197197 => ( (forall a. k a -> v a -> m (Compose ((,) (Event t w)) v' a))

198198 -> DMap k v

199199 -> Event t (p k v)

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

@@ -1157,7 +1157,9 @@ type ResultM = EventM

11571157

11581158{-# NOINLINE unsafeNewIORef #-}

11591159unsafeNewIORef :: a -> b -> IORef b

1160−unsafeNewIORef _ b = unsafePerformIO $ newIORef b

1160+unsafeNewIORef a b = unsafePerformIO $ do

1161+ touch a

1162+ newIORef b

11611163

11621164instance HasSpiderTimeline x => Functor (Event x) where

11631165 fmap f = push $ return . Just . f

src/Reflex/Widget/Basic.hsnew file+42

@@ -0,0 +1,42 @@

1+{-# LANGUAGE CPP #-}

2+{-# LANGUAGE ExplicitForAll #-}

3+{-# LANGUAGE MultiParamTypeClasses #-}

4+{-# LANGUAGE RecursiveDo #-}

5+#ifdef USE_REFLEX_OPTIMIZER

6+{-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-}

7+#endif

9+module Reflex.Widget.Basic where

10+

11+import Control.Monad.Fix (MonadFix)

12+import Data.Map (Map)

13+import Reflex.Class

14+import Reflex.Patch.MapWithMove

15+

16+

17+-- | Build sortable content in such a way that re-sorting it can cause minimal

18+-- disruption to an existing context.

19+--

20+-- Naively re-sorting a list of images would destroy every image and add them back

21+-- in the new order. This framework is able to avoid that by preserving the

22+-- identity of each image and simply moving it to the new location.

23+--

24+-- Example:

25+--

26+-- > let sortByFst = buttonA $> comparing fst

27+-- > sortBySnd = buttonB $> comparing snd

28+-- > sortEvent = leftmost [sortByFst, sortBySnd]

29+-- > sortableList

30+-- > (\k v -> text $ "\n" ++ show k ++ " " ++ v) -- show each element on a new line

31+-- > (Map.fromList $ zip [0..] [(3, "a"), (2, "b"), (1, "c")])

32+-- > sortEvent

33+sortableList :: forall t m k v a. (MonadHold t m, MonadFix m, MonadAdjust t m, Ord k)

34+ => (k -> v -> m a) -- ^ Function to render the content for each key/value pair

35+ -> Map k v -- ^ The sortable list with an initial ordering determined by the @Map@ keys in ascending order

36+ -> Event t (v -> v -> Ordering) -- ^ An event carrying a sort function for the list

37+ -> m (Map k a)

38+sortableList f m0 reSortFunc = do

39+ rec let reSortPatch = attachWith (flip patchThatSortsMapWith) (currentIncremental m) reSortFunc

40+ m <- holdIncremental m0 reSortPatch

41+ (results, _) <- mapMapWithAdjustWithMove f m0 reSortPatch

42+ pure results