0ebc91c · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Fix docs of re-exported module appearing twice

0ebc91cHarendra Kumar3 years ago

core/src/Streamly/Internal/Data/Array.hs+13−14

compare with master

unifiedsplit

@@ -104,7 +104,6 @@ import Streamly.Internal.System.IO (unsafeInlineIO)

104import qualified Streamly.Internal.Data.Serialize.Type as Serialize

105import qualified Streamly.Internal.Data.MutByteArray.Type as MBA

106import qualified Streamly.Internal.Data.MutArray as MA

107−import qualified Streamly.Internal.Data.Array.Type as A

108import qualified Streamly.Internal.Data.Fold as FL

107import qualified Streamly.Internal.Data.Fold as FL

109import qualified Streamly.Internal.Data.Ring as RB

108import qualified Streamly.Internal.Data.Ring as RB

110import qualified Streamly.Internal.Data.Stream as D

109import qualified Streamly.Internal.Data.Stream as D

@@ -149,7 +148,7 @@ import Streamly.Internal.Data.Array.Type

149-- /Pre-release/

148-- /Pre-release/

150{-# INLINE null #-}

149{-# INLINE null #-}

151null :: Array a -> Bool

150null :: Array a -> Bool

152−null arr = A.byteLength arr == 0

151+null arr = byteLength arr == 0

153

152

154-- | Like 'getIndex' but indexes the array in reverse from the end.

153-- | Like 'getIndex' but indexes the array in reverse from the end.

155--

154--

@@ -185,7 +184,7 @@ writeLastN ::

185 (Storable a, Unbox a, MonadIO m) => Int -> Fold m a (Array a)

184 (Storable a, Unbox a, MonadIO m) => Int -> Fold m a (Array a)

186writeLastN n

185writeLastN n

187 | n <= 0 = fmap (const mempty) FL.drain

186 | n <= 0 = fmap (const mempty) FL.drain

188− | otherwise = A.unsafeFreeze <$> Fold step initial done done

187+ | otherwise = unsafeFreeze <$> Fold step initial done done

189

188

190 where

189 where

191

190

@@ -289,7 +288,7 @@ splitOn :: (Monad m, Unbox a) =>

289 (a -> Bool) -> Array a -> Stream m (Array a)

288 (a -> Bool) -> Array a -> Stream m (Array a)

290splitOn predicate arr =

289splitOn predicate arr =

291 fmap (\(i, len) -> getSliceUnsafe i len arr)

290 fmap (\(i, len) -> getSliceUnsafe i len arr)

292− $ D.indexOnSuffix predicate (A.read arr)

291+ $ D.indexOnSuffix predicate (read arr)

293

292

294{-# INLINE sliceIndexerFromLen #-}

293{-# INLINE sliceIndexerFromLen #-}

295sliceIndexerFromLen :: forall m a. (Monad m, Unbox a)

294sliceIndexerFromLen :: forall m a. (Monad m, Unbox a)

@@ -297,7 +296,7 @@ sliceIndexerFromLen :: forall m a. (Monad m, Unbox a)

297 -> Int -- ^ length of the slice

296 -> Int -- ^ length of the slice

298 -> Unfold m (Array a) (Int, Int)

297 -> Unfold m (Array a) (Int, Int)

299sliceIndexerFromLen from len =

298sliceIndexerFromLen from len =

300− Unfold.lmap A.unsafeThaw (MA.sliceIndexerFromLen from len)

299+ Unfold.lmap unsafeThaw (MA.sliceIndexerFromLen from len)

301

300

302{-# DEPRECATED genSlicesFromLen "Please use sliceIndexerFromLen instead." #-}

301{-# DEPRECATED genSlicesFromLen "Please use sliceIndexerFromLen instead." #-}

303genSlicesFromLen :: forall m a. (Monad m, Unbox a)

302genSlicesFromLen :: forall m a. (Monad m, Unbox a)

@@ -317,8 +316,8 @@ slicerFromLen :: forall m a. (Monad m, Unbox a)

317 -> Int -- ^ length of the slice

316 -> Int -- ^ length of the slice

318 -> Unfold m (Array a) (Array a)

317 -> Unfold m (Array a) (Array a)

319slicerFromLen from len =

318slicerFromLen from len =

320− fmap A.unsafeFreeze

319+ fmap unsafeFreeze

321− $ Unfold.lmap A.unsafeThaw (MA.slicerFromLen from len)

320+ $ Unfold.lmap unsafeThaw (MA.slicerFromLen from len)

322

321

323{-# DEPRECATED getSlicesFromLen "Please use slicerFromLen instead." #-}

322{-# DEPRECATED getSlicesFromLen "Please use slicerFromLen instead." #-}

324getSlicesFromLen :: forall m a. (Monad m, Unbox a)

323getSlicesFromLen :: forall m a. (Monad m, Unbox a)

@@ -367,7 +366,7 @@ getIndex i arr =

367indexReader :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a

366indexReader :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a

368indexReader m =

367indexReader m =

369 let unf = MA.indexReaderWith (return . unsafeInlineIO) m

368 let unf = MA.indexReaderWith (return . unsafeInlineIO) m

370− in Unfold.lmap A.unsafeThaw unf

369+ in Unfold.lmap unsafeThaw unf

371

370

372-- XXX DO NOT REMOVE, change the signature to use Stream instead of unfold

371-- XXX DO NOT REMOVE, change the signature to use Stream instead of unfold

373{-# DEPRECATED getIndices "Please use getIndices instead." #-}

372{-# DEPRECATED getIndices "Please use getIndices instead." #-}

@@ -407,7 +406,7 @@ indexReaderFromThenTo = undefined

407{-# INLINE runPipe #-}

406{-# INLINE runPipe #-}

408runPipe :: (MonadIO m, Unbox a, Unbox b)

407runPipe :: (MonadIO m, Unbox a, Unbox b)

409 => Pipe m a b -> Array a -> m (Array b)

408 => Pipe m a b -> Array a -> m (Array b)

410−runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (A.read arr)

409+runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (read arr)

411-}

410-}

412

411

413-- XXX For transformations that cannot change the number of elements e.g. "map"

412-- XXX For transformations that cannot change the number of elements e.g. "map"

@@ -421,7 +420,7 @@ runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (A.read arr)

421streamTransform :: forall m a b. (MonadIO m, Unbox a, Unbox b)

420streamTransform :: forall m a b. (MonadIO m, Unbox a, Unbox b)

422 => (Stream m a -> Stream m b) -> Array a -> m (Array b)

421 => (Stream m a -> Stream m b) -> Array a -> m (Array b)

423streamTransform f arr =

422streamTransform f arr =

424− Stream.fold (A.writeWith (length arr)) $ f (A.read arr)

423+ Stream.fold (writeWith (length arr)) $ f (read arr)

425

424

426-------------------------------------------------------------------------------

425-------------------------------------------------------------------------------

427-- Casts

426-- Casts

@@ -455,7 +454,7 @@ asBytes = castUnsafe

455--

454--

456cast :: forall a b. (Unbox b) => Array a -> Maybe (Array b)

455cast :: forall a b. (Unbox b) => Array a -> Maybe (Array b)

457cast arr =

456cast arr =

458− let len = A.byteLength arr

457+ let len = byteLength arr

459 r = len `mod` SIZE_OF(b)

458 r = len `mod` SIZE_OF(b)

460 in if r /= 0

459 in if r /= 0

461 then Nothing

460 then Nothing

@@ -473,7 +472,7 @@ cast arr =

473--

472--

474asCStringUnsafe :: Array a -> (CString -> IO b) -> IO b

473asCStringUnsafe :: Array a -> (CString -> IO b) -> IO b

475asCStringUnsafe arr act = do

474asCStringUnsafe arr act = do

476− let arr1 = asBytes arr <> A.fromList [0]

475+ let arr1 = asBytes arr <> fromList [0]

477 -- asPtrUnsafe makes sure the array is pinned

476 -- asPtrUnsafe makes sure the array is pinned

478 asPtrUnsafe arr1 $ \ptr -> act (castPtr ptr)

477 asPtrUnsafe arr1 $ \ptr -> act (castPtr ptr)

479

478

@@ -488,14 +487,14 @@ asCStringUnsafe arr act = do

488-- /Pre-release/

487-- /Pre-release/

489{-# INLINE fold #-}

488{-# INLINE fold #-}

490fold :: forall m a b. (Monad m, Unbox a) => Fold m a b -> Array a -> m b

489fold :: forall m a b. (Monad m, Unbox a) => Fold m a b -> Array a -> m b

491−fold f arr = Stream.fold f (A.read arr)

490+fold f arr = Stream.fold f (read arr)

492

491

493-- | Fold an array using a stream fold operation.

492-- | Fold an array using a stream fold operation.

494--

493--

495-- /Pre-release/

494-- /Pre-release/

496{-# INLINE streamFold #-}

495{-# INLINE streamFold #-}

497streamFold :: (Monad m, Unbox a) => (Stream m a -> m b) -> Array a -> m b

496streamFold :: (Monad m, Unbox a) => (Stream m a -> m b) -> Array a -> m b

498−streamFold f arr = f (A.read arr)

497+streamFold f arr = f (read arr)

499

498

500--------------------------------------------------------------------------------

499--------------------------------------------------------------------------------

501-- Serialization

500-- Serialization