a87bf85 · streamly · git.iko.soy

git.iko.soy/streamly

Expose the Enumeration APIs from the Unfold module (#2377)

Co-authored-by: Harendra Kumar <harendra@composewell.com>

commita87bf8506e46ed2a12af1327b06ff32bfd97aea1 authorRanjeet Ranjan <ranjeetr@composewell.com> dateThu 20 Jul 2023, 19:52 (3 years ago) parentad19cf7

3 files changed+22−74

compare with master

unifiedsplit

core/src/Streamly/Data/Unfold.hs+3 core/src/Streamly/Internal/Data/Unfold.hs+5−30 core/src/Streamly/Internal/Data/Unfold/Enumeration.hs+14−44

core/src/Streamly/Data/Unfold.hs+3

@@ -53,6 +53,9 @@ module Streamly.Data.Unfold

5353 , replicateM

5454 , iterateM

5555

56+ -- ** Enumeration

57+ , Enumerable (..)

58+

5659 -- ** From Containers

5760 , fromList

5861 , fromListM

core/src/Streamly/Internal/Data/Unfold.hs+5−30

@@ -46,36 +46,7 @@ module Streamly.Internal.Data.Unfold

4646 , iterateM

4747

4848 -- ** Enumerations

49− , Enumerable (..)

50−

51− -- ** Enumerate Num

52− , enumerateFromNum

53− , enumerateFromThenNum

54− , enumerateFromStepNum

55−

56− -- ** Enumerating 'Bounded 'Integral' Types

57− , enumerateFromIntegralBounded

58− , enumerateFromThenIntegralBounded

59− , enumerateFromToIntegralBounded

60− , enumerateFromThenToIntegralBounded

61−

62− -- ** Enumerating 'Unounded Integral' Types

63− , enumerateFromIntegral

64− , enumerateFromThenIntegral

65− , enumerateFromToIntegral

66− , enumerateFromThenToIntegral

67−

68− -- ** Enumerating 'Small Integral' Types

69− , enumerateFromSmallBounded

70− , enumerateFromThenSmallBounded

71− , enumerateFromToSmall

72− , enumerateFromThenToSmall

73−

74− -- ** Enumerating 'Fractional' Types

75− , enumerateFromFractional

76− , enumerateFromThenFractional

77− , enumerateFromToFractional

78− , enumerateFromThenToFractional

49+ , module Streamly.Internal.Data.Unfold.Enumeration

7950

8051 -- ** From Containers

8152 , fromList

@@ -210,6 +181,10 @@ import Foreign.Ptr

210181

211182#include "DocTestDataUnfold.hs"

212183

184+-------------------------------------------------------------------------------

185+-- Input operations

186+-------------------------------------------------------------------------------

187+

213188-- | Convert an 'Unfold' into an unfold accepting a tuple as an argument,

214189-- using the argument of the original fold as the second element of tuple and

215190-- discarding the first element of the tuple.

core/src/Streamly/Internal/Data/Unfold/Enumeration.hs+14−44

@@ -88,7 +88,7 @@ import Prelude

8888-- the value overflows it keeps enumerating in a cycle:

8989--

9090-- @

91−-- >>> Stream.fold Fold.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromStepNum (255::Word8,1)

91+-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromStepNum (255::Word8,1)

9292-- [255,0,1,2,3,4,5,6,7,8]

9393--

9494-- @

@@ -125,7 +125,7 @@ enumerateFromStepNum = Unfold step inject

125125--

126126-- Example:

127127-- @

128−-- >>> Stream.fold Fold.toList $ Stream.take 10 $ Stream.unfold enumerateFromThenNum (255::Word8,0)

128+-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold enumerateFromThenNum (255::Word8,0)

129129-- [255,0,1,2,3,4,5,6,7,8]

130130--

131131-- @

@@ -152,7 +152,7 @@ enumerateFromThenNum =

152152--

153153-- @

154154-- >>> enumerateFromNum = lmap (\from -> (from, 1)) Unfold.enumerateFromStepNum

155−-- >>> Stream.fold Fold.toList $ Stream.take 6 $ Stream.unfold enumerateFromNum (0.9)

155+-- >>> Stream.toList $ Stream.take 6 $ Stream.unfold enumerateFromNum (0.9)

156156-- [0.9,1.9,2.9,3.9,4.9,5.9]

157157--

158158-- @

@@ -162,7 +162,7 @@ enumerateFromThenNum =

162162--

163163-- @

164164-- >>> enumerateFromNum = lmap (\from -> (from, from + 1)) Unfold.enumerateFromThenNum

165−-- >>> Stream.fold Fold.toList $ Stream.take 6 $ Stream.unfold enumerateFromNum (0.9)

165+-- >>> Stream.toList $ Stream.take 6 $ Stream.unfold enumerateFromNum (0.9)

166166-- [0.9,1.9,2.9,3.8999999999999995,4.8999999999999995,5.8999999999999995]

167167--

168168-- @

@@ -284,7 +284,7 @@ enumerateFromThenFractional = enumerateFromThenNum

284284-- specified upper limit rounded to the nearest integral value:

285285--

286286-- @

287−-- >>> Stream.fold Fold.toList $ Stream.unfold Unfold.enumerateFromToFractional (0.1, 6.3)

287+-- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromToFractional (0.1, 6.3)

288288-- [0.1,1.1,2.1,3.1,4.1,5.1,6.1]

289289--

290290-- @

@@ -389,24 +389,15 @@ class Enum a => Enumerable a where

389389 -- @from@, enumerating up to 'maxBound' when the type is 'Bounded' or

390390 -- generating an infinite stream when the type is not 'Bounded'.

391391 --

392− -- >>> import qualified Streamly.Data.Stream as Stream

393− -- >>> import qualified Streamly.Internal.Data.Unfold as Unfold

394− --

395− -- @

396− -- >>> Stream.fold Fold.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFrom (0 :: Int)

392+ -- >>> Stream.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFrom (0 :: Int)

397393 -- [0,1,2,3]

398394 --

399− -- @

400− --

401395 -- For 'Fractional' types, enumeration is numerically stable. However, no

402396 -- overflow or underflow checks are performed.

403397 --

404− -- @

405− -- >>> Stream.fold Fold.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFrom 1.1

398+ -- >>> Stream.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFrom 1.1

406399 -- [1.1,2.1,3.1,4.1]

407400 --

408− -- @

409− --

410401 -- /Pre-release/

411402 --

412403 enumerateFrom :: Monad m => Unfold m a a

@@ -415,27 +406,18 @@ class Enum a => Enumerable a where

415406 -- @from@, enumerating the type up to the value @to@. If @to@ is smaller than

416407 -- @from@ then an empty stream is returned.

417408 --

418− -- >>> import qualified Streamly.Data.Stream as Stream

419− -- >>> import qualified Streamly.Internal.Data.Unfold as Unfold

420− --

421− -- @

422− -- >>> Stream.fold Fold.toList $ Stream.unfold Unfold.enumerateFromTo (0, 4)

409+ -- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromTo (0, 4)

423410 -- [0,1,2,3,4]

424411 --

425− -- @

426− --

427412 -- For 'Fractional' types, the last element is equal to the specified @to@

428413 -- value after rounding to the nearest integral value.

429414 --

430− -- @

431− -- >>> Stream.fold Fold.toList $ Stream.unfold Unfold.enumerateFromTo (1.1, 4)

415+ -- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromTo (1.1, 4)

432416 -- [1.1,2.1,3.1,4.1]

433417 --

434− -- >>> Stream.fold Fold.toList $ Stream.unfold Unfold.enumerateFromTo (1.1, 4.6)

418+ -- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromTo (1.1, 4.6)

435419 -- [1.1,2.1,3.1,4.1,5.1]

436420 --

437− -- @

438− --

439421 -- /Pre-release/

440422 enumerateFromTo :: Monad m => Unfold m (a, a) a

441423

@@ -445,18 +427,12 @@ class Enum a => Enumerable a where

445427 -- after @from@. For 'Bounded' types the stream ends when 'maxBound' is

446428 -- reached, for unbounded types it keeps enumerating infinitely.

447429 --

448− -- >>> import qualified Streamly.Data.Stream as Stream

449− -- >>> import qualified Streamly.Internal.Data.Unfold as Unfold

450− --

451− -- @

452− -- >>> Stream.fold Fold.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFromThen (0, 2)

430+ -- >>> Stream.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFromThen (0, 2)

453431 -- [0,2,4,6]

454432 --

455− -- >>> Stream.fold Fold.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFromThen (0,(-2))

433+ -- >>> Stream.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFromThen (0,(-2))

456434 -- [0,-2,-4,-6]

457435 --

458− -- @

459− --

460436 -- /Pre-release/

461437 enumerateFromThen :: Monad m => Unfold m (a, a) a

462438

@@ -465,18 +441,12 @@ class Enum a => Enumerable a where

465441 -- @to@. Enumeration can occur downwards or upwards depending on whether @then@

466442 -- comes before or after @from@.

467443 --

468− -- >>> import qualified Streamly.Data.Stream as Stream

469− -- >>> import qualified Streamly.Internal.Data.Unfold as Unfold

470− --

471− -- @

472− -- >>> Stream.fold Fold.toList $ Stream.unfold Unfold.enumerateFromThenTo (0, 2, 6)

444+ -- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromThenTo (0, 2, 6)

473445 -- [0,2,4,6]

474446 --

475− -- >>> Stream.fold Fold.toList $ Stream.unfold Unfold.enumerateFromThenTo (0, (-2), (-6))

447+ -- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromThenTo (0, (-2), (-6))

476448 -- [0,-2,-4,-6]

477449 --

478− -- @

479− --

480450 -- /Pre-release/

481451 enumerateFromThenTo :: Monad m => Unfold m (a, a, a) a

482452