a054c81 · streamly · git.iko.soy

15 ) where

16

17import Control.DeepSeq (NFData(..))

18−import Control.Monad.Catch (MonadCatch, try, SomeException)

18+import Control.Monad.Catch (MonadCatch, MonadThrow, try, SomeException)

19import Data.Foldable (asum)

20import Data.Functor (($>))

21import Data.Maybe (fromMaybe)

112-------------------------------------------------------------------------------

113

114{-# INLINE one #-}

115−one :: MonadCatch m => Int -> Stream m Int -> m (Maybe Int)

115+one :: MonadThrow m => Int -> Stream m Int -> m (Maybe Int)

116one value = Stream.parse p

117

118 where

124 Nothing -> pure Nothing

125

126{-# INLINE takeBetween #-}

127−takeBetween :: MonadCatch m => Int -> Stream m a -> m ()

127+takeBetween :: MonadThrow m => Int -> Stream m a -> m ()

128takeBetween value = Stream.parse (PR.takeBetween 0 value Fold.drain)

129

130{-# INLINE takeEQ #-}

131−takeEQ :: MonadCatch m => Int -> Stream m a -> m ()

131+takeEQ :: MonadThrow m => Int -> Stream m a -> m ()

132takeEQ value = Stream.parse (PR.takeEQ value Fold.drain)

133

134{-# INLINE dropWhile #-}

135−dropWhile :: MonadCatch m => Int -> Stream m Int -> m ()

135+dropWhile :: MonadThrow m => Int -> Stream m Int -> m ()

136dropWhile value = Stream.parse (PR.dropWhile (<= value))

137

138{-# INLINE takeStartBy #-}

139−takeStartBy :: MonadCatch m => Int -> Stream m Int -> m ()

139+takeStartBy :: MonadThrow m => Int -> Stream m Int -> m ()

140takeStartBy value stream = do

141 stream1 <- return . fromMaybe (Stream.fromPure (value + 1)) =<< IsStream.tail stream

142 let stream2 = value `Stream.cons` stream1

143 Stream.parse (PR.takeStartBy (== value) Fold.drain) stream2

144

145−takeFramedByEsc_ :: MonadCatch m => Int -> Stream m Char -> m ()

145+takeFramedByEsc_ :: MonadThrow m => Int -> Stream m Char -> m ()

146takeFramedByEsc_ _ = Stream.parse parser

147

148 where

154 parser = PR.takeFramedByEsc_ isEsc isBegin isEnd Fold.drain

155

156{-# INLINE takeWhile #-}

157−takeWhile :: MonadCatch m => Int -> Stream m Int -> m ()

157+takeWhile :: MonadThrow m => Int -> Stream m Int -> m ()

158takeWhile value = Stream.parse (PR.takeWhile (<= value) Fold.drain)

159

160−takeWhileP :: MonadCatch m => Int -> Stream m Int -> m ()

160+takeWhileP :: MonadThrow m => Int -> Stream m Int -> m ()

161takeWhileP value =

162 Stream.parse (PR.takeWhileP (<= value) (PR.takeWhile (<= value - 1) Fold.drain))

163

164{-# INLINE takeP #-}

165−takeP :: MonadCatch m => Int -> Stream m a -> m ()

165+takeP :: MonadThrow m => Int -> Stream m a -> m ()

166takeP value = Stream.parse (PR.takeP value (PR.fromFold Fold.drain))

167

168{-# INLINE groupBy #-}

169−groupBy :: MonadCatch m => Stream m Int -> m ()

169+groupBy :: MonadThrow m => Stream m Int -> m ()

170groupBy = Stream.parse (PR.groupBy (<=) Fold.drain)

171

172{-# INLINE groupByRolling #-}

173−groupByRolling :: MonadCatch m => Stream m Int -> m ()

173+groupByRolling :: MonadThrow m => Stream m Int -> m ()

174groupByRolling = Stream.parse (PR.groupByRolling (<=) Fold.drain)

175

176{-# INLINE wordBy #-}

177−wordBy :: MonadCatch m => Int -> Stream m Int -> m ()

177+wordBy :: MonadThrow m => Int -> Stream m Int -> m ()

178wordBy value = Stream.parse (PR.wordBy (>= value) Fold.drain)

179

180{-# INLINE sepByWords #-}

181−sepByWords :: MonadCatch m => Int -> Stream m Int -> m ()

181+sepByWords :: MonadThrow m => Int -> Stream m Int -> m ()

182sepByWords _ = Stream.parse (wrds even Fold.drain)

183 where

184 wrds p f = PR.sepBy f (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)

185

186{-# INLINE deintercalate #-}

187−deintercalate :: MonadCatch m => Int -> Stream m Int -> m ()

187+deintercalate :: MonadThrow m => Int -> Stream m Int -> m ()

188deintercalate _ = Stream.parse (partition even)

189

190 where

194 Fold.drain (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum)

195

196{-# INLINE manyWordByEven #-}

197−manyWordByEven :: MonadCatch m => Stream m Int -> m ()

197+manyWordByEven :: MonadThrow m => Stream m Int -> m ()

198manyWordByEven = Stream.parse (PR.many (PR.wordBy even Fold.drain) Fold.drain)

199

200{-# INLINE many #-}

201−many :: MonadCatch m => Stream m Int -> m Int

201+many :: MonadThrow m => Stream m Int -> m Int

202many = Stream.parse (PR.many (PR.satisfy (> 0)) Fold.length)

203

204{-# INLINE manyAlt #-}

205−manyAlt :: MonadCatch m => Stream m Int -> m Int

205+manyAlt :: MonadThrow m => Stream m Int -> m Int

206manyAlt xs = do

207 x <- Stream.parse (AP.many (PR.satisfy (> 0))) xs

208 return $ Prelude.length x

209

210{-# INLINE some #-}

211−some :: MonadCatch m => Stream m Int -> m Int

211+some :: MonadThrow m => Stream m Int -> m Int

212some = Stream.parse (PR.some (PR.satisfy (> 0)) Fold.length)

213

214{-# INLINE someAlt #-}

215−someAlt :: MonadCatch m => Stream m Int -> m Int

215+someAlt :: MonadThrow m => Stream m Int -> m Int

216someAlt xs = do

217 x <- Stream.parse (AP.some (PR.satisfy (> 0))) xs

218 return $ Prelude.length x

219

220{-# INLINE manyTill #-}

221−manyTill :: MonadCatch m => Int -> Stream m Int -> m Int

221+manyTill :: MonadThrow m => Int -> Stream m Int -> m Int

222manyTill value =

223 Stream.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) Fold.length)

224

225{-# INLINE splitAp #-}

226−splitAp :: MonadCatch m

226+splitAp :: MonadThrow m

227 => Int -> Stream m Int -> m ((), ())

228splitAp value =

229 Stream.parse

233 )

234

235{-# INLINE splitApBefore #-}

236−splitApBefore :: MonadCatch m

236+splitApBefore :: MonadThrow m

237 => Int -> Stream m Int -> m ()

238splitApBefore value =

239 Stream.parse

242 )

243

244{-# INLINE splitApAfter #-}

245−splitApAfter :: MonadCatch m

245+splitApAfter :: MonadThrow m

246 => Int -> Stream m Int -> m ()

247splitApAfter value =

248 Stream.parse

251 )

252

253{-# INLINE serialWith #-}

254−serialWith :: MonadCatch m

254+serialWith :: MonadThrow m

255 => Int -> Stream m Int -> m ((), ())

256serialWith value =

257 Stream.parse

261 )

262

263{-# INLINE split_ #-}

264−split_ :: MonadCatch m

264+split_ :: MonadThrow m

265 => Int -> Stream m Int -> m ()

266split_ value =

267 Stream.parse

271 )

272

273{-# INLINE takeEndBy_ #-}

274−takeEndBy_ :: MonadCatch m

274+takeEndBy_ :: MonadThrow m

275 => Int -> Stream m Int -> m()

276takeEndBy_ value = Stream.parse (PR.takeEndBy_ (>= value) (PR.fromFold Fold.drain))

277

278{-

279{-# INLINE teeAllAny #-}

280−teeAllAny :: MonadCatch m

280+teeAllAny :: MonadThrow m

281 => Int -> Stream m Int -> m ((), ())

282teeAllAny value =

283 Stream.parse

287 )

288

289{-# INLINE teeFstAllAny #-}

290−teeFstAllAny :: MonadCatch m

290+teeFstAllAny :: MonadThrow m

291 => Int -> Stream m Int -> m ((), ())

292teeFstAllAny value =

293 Stream.parse

297 )

298

299{-# INLINE shortestAllAny #-}

300−shortestAllAny :: MonadCatch m

300+shortestAllAny :: MonadThrow m

301 => Int -> Stream m Int -> m ()

302shortestAllAny value =

303 Stream.parse

307 )

308

309{-# INLINE longestAllAny #-}

310−longestAllAny :: MonadCatch m

310+longestAllAny :: MonadThrow m

311 => Int -> Stream m Int -> m ()

312longestAllAny value =

313 Stream.parse

349-- not have to rely on it.

350--

351{-# INLINE lookAhead #-}

352−lookAhead :: MonadCatch m => Int -> Stream m Int -> m ()

352+lookAhead :: MonadThrow m => Int -> Stream m Int -> m ()

353lookAhead value =

354 Stream.parse (PR.lookAhead (PR.takeWhile (<= value) Fold.drain) $> ())

355

356{-# INLINE sequenceA #-}

357−sequenceA :: MonadCatch m => Int -> Stream m Int -> m Int

357+sequenceA :: MonadThrow m => Int -> Stream m Int -> m Int

358sequenceA value xs = do

359 x <- Stream.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

360 return $ length x

361

362{-# INLINE sequenceA_ #-}

363−sequenceA_ :: MonadCatch m => Int -> Stream m Int -> m ()

363+sequenceA_ :: MonadThrow m => Int -> Stream m Int -> m ()

364sequenceA_ value =

365 Stream.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

366

367{-# INLINE sequence #-}

368−sequence :: MonadCatch m => Int -> Stream m Int -> m Int

368+sequence :: MonadThrow m => Int -> Stream m Int -> m Int

369sequence value xs = do

370 x <- Stream.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

371 return $ length x

372

373{-# INLINE sequence_ #-}

374−sequence_ :: MonadCatch m => Int -> Stream m Int -> m ()

374+sequence_ :: MonadThrow m => Int -> Stream m Int -> m ()

375sequence_ value =

376 Stream.parse (F.sequence_ $ replicate value (PR.satisfy (> 0)))

377

378{-# INLINE choiceAsum #-}

379−choiceAsum :: MonadCatch m => Int -> Stream m Int -> m Int

379+choiceAsum :: MonadThrow m => Int -> Stream m Int -> m Int

380choiceAsum value =

381 Stream.parse (asum (replicate value (PR.satisfy (< 0)))

382 AP.<|> PR.satisfy (> 0))

383

384{-

385{-# INLINE choice #-}

386−choice :: MonadCatch m => Int -> Stream m Int -> m Int

386+choice :: MonadThrow m => Int -> Stream m Int -> m Int

387choice value =

388 Stream.parse

389 (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))

394-------------------------------------------------------------------------------

395

396{-# INLINE parseMany #-}

397−parseMany :: MonadCatch m => Int -> Stream m Int -> m ()

397+parseMany :: MonadThrow m => Int -> Stream m Int -> m ()

398parseMany n =

399 Stream.fold Fold.drain

400 . fmap getSum

402 . fmap Sum

403

404{-# INLINE parseIterate #-}

405−parseIterate :: MonadCatch m => Int -> Stream m Int -> m ()

405+parseIterate :: MonadThrow m => Int -> Stream m Int -> m ()

406parseIterate n =

407 Stream.fold Fold.drain

408 . fmap getSum

418 Right (_, s1) -> parseBreak s1

419

420{-# INLINE concatSequence #-}

421−concatSequence :: MonadCatch m => Stream m Int -> m ()

421+concatSequence :: MonadThrow m => Stream m Int -> m ()

422concatSequence = Stream.parse $ PR.concatSequence Fold.drain $ Stream.repeat PR.one

423

424-------------------------------------------------------------------------------