1f502b1 · streamly · git.iko.soy

254

255-- fromIndices

256

257−{-# INLINE sourceFromIndices #-}

257+{-# INLINE _sourceFromIndices #-}

258−sourceFromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

258+_sourceFromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

259−sourceFromIndices value n = S.take value $ S.fromIndices (+ n)

259+_sourceFromIndices value n = S.take value $ S.fromIndices (+ n)

260

261−{-# INLINE sourceFromIndicesM #-}

261+{-# INLINE _sourceFromIndicesM #-}

262−sourceFromIndicesM :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

262+_sourceFromIndicesM :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

263−sourceFromIndicesM value n = S.take value $ S.fromIndicesM (P.fmap return (+ n))

263+_sourceFromIndicesM value n = S.take value $ S.fromIndicesM (P.fmap return (+ n))

264

265-- fromList

266

306{-# INLINE toList #-}

307toList :: Monad m => Stream m Int -> m [Int]

308

309−{-# INLINE head #-}

309+{-# INLINE _head #-}

310{-# INLINE last #-}

311{-# INLINE maximum #-}

312{-# INLINE minimum #-}

314{-# INLINE findIndex #-}

315{-# INLINE elemIndex #-}

316{-# INLINE foldl1'Reduce #-}

317−head, last, minimum, maximum, foldl1'Reduce

317+_head, last, minimum, maximum, foldl1'Reduce

318 :: Monad m => Stream m Int -> m (Maybe Int)

319

320find, findIndex, elemIndex

346{-# INLINE any #-}

347{-# INLINE and #-}

348{-# INLINE or #-}

349−{-# INLINE null #-}

349+{-# INLINE _null #-}

350{-# INLINE elem #-}

351{-# INLINE notElem #-}

352−null :: Monad m => Stream m Int -> m Bool

352+_null :: Monad m => Stream m Int -> m Bool

353

354elem, notElem, all, any, and, or :: Monad m => Int -> Stream m Int -> m Bool

355

411foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) 0

412

413last = S.last

414−null = S.null

414+_null = S.null

415−head = S.head

415+_head = S.head

416elem value = S.elem (value + 1)

417notElem value = S.notElem (value + 1)

418length = S.length

471{-# INLINE filterEven #-}

472{-# INLINE filterAllOut #-}

473{-# INLINE filterAllIn #-}

474−{-# INLINE takeOne #-}

474+{-# INLINE _takeOne #-}

475{-# INLINE takeAll #-}

476{-# INLINE takeWhileTrue #-}

477−{-# INLINE takeWhileMTrue #-}

477+{-# INLINE _takeWhileMTrue #-}

478{-# INLINE dropOne #-}

479{-# INLINE dropAll #-}

480{-# INLINE dropWhileTrue #-}

481−{-# INLINE dropWhileMTrue #-}

481+{-# INLINE _dropWhileMTrue #-}

482{-# INLINE dropWhileFalse #-}

483{-# INLINE findIndices #-}

484{-# INLINE elemIndices #-}

491{-# INLINE foldrT #-}

492{-# INLINE foldrTMap #-}

493scan, scanl1', map, fmap, mapMaybe, filterEven,

494− takeOne, dropOne,

494+ _takeOne, dropOne,

495 reverse, reverse',

496 foldrS, foldrSMap, foldrT, foldrTMap

497 :: MonadIO m

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

499

500filterAllOut,

501− filterAllIn, takeAll, takeWhileTrue, takeWhileMTrue,

501+ filterAllIn, takeAll, takeWhileTrue, _takeWhileMTrue,

502− dropAll, dropWhileTrue, dropWhileMTrue, dropWhileFalse,

502+ dropAll, dropWhileTrue, _dropWhileMTrue, dropWhileFalse,

503 findIndices, elemIndices, insertBy, deleteBy

504 :: MonadIO m

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

562filterEven n = composeN n $ S.filter even

563filterAllOut value n = composeN n $ S.filter (> (value + 1))

564filterAllIn value n = composeN n $ S.filter (<= (value + 1))

565−takeOne n = composeN n $ S.take 1

565+_takeOne n = composeN n $ S.take 1

566takeAll value n = composeN n $ S.take (value + 1)

567takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))

568−takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))

568+_takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))

569dropOne n = composeN n $ S.drop 1

570dropAll value n = composeN n $ S.drop (value + 1)

571dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))

572−dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))

572+_dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))

573dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))

574findIndices value n = composeN n $ S.findIndices (== (value + 1))

575elemIndices value n = composeN n $ S.elemIndices (value + 1)

1218foldableProduct value n =

1219 P.product (sourceUnfoldr value n :: S.SerialT Identity Int)

1220

1221−{-# INLINE foldableNull #-}

1221+{-# INLINE _foldableNull #-}

1222−foldableNull :: Int -> Int -> Bool

1222+_foldableNull :: Int -> Int -> Bool

1223−foldableNull value n =

1223+_foldableNull value n =

1224 P.null (sourceUnfoldr value n :: S.SerialT Identity Int)

1225

1226{-# INLINE foldableElem #-}

1302foldableSequence_ value n =

1303 F.sequence_ (sourceUnfoldrAction value n :: S.SerialT Identity (IO Int))

1304

1305−{-# INLINE foldableMsum #-}

1305+{-# INLINE _foldableMsum #-}

1306−foldableMsum :: Int -> Int -> IO Int

1306+_foldableMsum :: Int -> Int -> IO Int

1307−foldableMsum value n =

1307+_foldableMsum value n =

1308 F.msum (sourceUnfoldrAction value n :: S.SerialT Identity (IO Int))

1309

1310-------------------------------------------------------------------------------

1436 -- type class operations

1437 [ bench "foldl'" $ nf (foldableFoldl' value) 1

1438 , bench "foldrElem" $ nf (foldableFoldrElem value) 1

1439− -- , bench "null" $ nf (foldableNull value) 1

1439+ -- , bench "null" $ nf (_foldableNull value) 1

1440 , bench "elem" $ nf (foldableElem value) 1

1441 , bench "length" $ nf (foldableLength value) 1

1442 , bench "sum" $ nf (foldableSum value) 1

1462 , benchIOSink1 "sequence_" (foldableSequence_ value)

1463 -- TBD: sequenceA_

1464 -- TBD: asum

1465− -- , benchIOSink1 "msum" (foldableMsum value)

1465+ -- , benchIOSink1 "msum" (_foldableMsum value)

1466 ]

1467 ]

1468 ]

1846 "takeByTime-all"

1847 (takeByTime (NanoSecond64 maxBound) 1)

1848 , benchIOSink value "takeWhile-true" (takeWhileTrue value 1)

1849− --, benchIOSink value "takeWhileM-true" (takeWhileMTrue 1)

1849+ --, benchIOSink value "takeWhileM-true" (_takeWhileMTrue 1)

1850 -- "drop-one" is dual to "last"

1851 , benchIOSink value "drop-one" (dropOne 1)

1852 , benchIOSink value "drop-all" (dropAll value 1)

1855 "dropByTime-all"

1856 (dropByTime (NanoSecond64 maxBound) 1)

1857 , benchIOSink value "dropWhile-true" (dropWhileTrue value 1)

1858− --, benchIOSink value "dropWhileM-true" (dropWhileMTrue 1)

1858+ --, benchIOSink value "dropWhileM-true" (_dropWhileMTrue 1)

1859 , benchIOSink

1860 value

1861 "dropWhile-false"

1878 , benchIOSink value "filter-all-in" (filterAllIn value 4)

1879 , benchIOSink value "take-all" (takeAll value 4)

1880 , benchIOSink value "takeWhile-true" (takeWhileTrue value 4)

1881− --, benchIOSink value "takeWhileM-true" (takeWhileMTrue 4)

1881+ --, benchIOSink value "takeWhileM-true" (_takeWhileMTrue 4)

1882 , benchIOSink value "drop-one" (dropOne 4)

1883 , benchIOSink value "drop-all" (dropAll value 4)

1884 , benchIOSink value "dropWhile-true" (dropWhileTrue value 4)

1885− --, benchIOSink value "dropWhileM-true" (dropWhileMTrue 4)

1885+ --, benchIOSink value "dropWhileM-true" (_dropWhileMTrue 4)

1886 , benchIOSink

1887 value

1888 "dropWhile-false"