a87bf85 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

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

a87bf85Ranjeet Ranjan3 years ago

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

compare with master

unifiedsplit

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

53 , replicateM

54 , iterateM

56+ -- ** Enumeration

57+ , Enumerable (..)

58+

56 -- ** From Containers

59 -- ** From Containers

57 , fromList

60 , fromList

58 , fromListM

61 , fromListM

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

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

46 , iterateM

48 -- ** Enumerations

49− , Enumerable (..)

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

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

80 -- ** From Containers

51 -- ** From Containers

81 , fromList

52 , fromList

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

210

181

211#include "DocTestDataUnfold.hs"

182#include "DocTestDataUnfold.hs"

212

183

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

185+-- Input operations

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

187+

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

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

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

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

215-- discarding the first element of the tuple.

190-- discarding the first element of the tuple.

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

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

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

89--

90-- @

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)

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

93--

94-- @

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

125--

126-- Example:

127-- @

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)

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

130--

131-- @

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

152--

153-- @

154-- >>> 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)

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

157--

158-- @

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

162--

163-- @

164-- >>> 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)

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

167--

168-- @

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

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

285--

286-- @

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

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

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

289--

290-- @

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

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

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

391 --

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)

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

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

398 --

394 --

399− -- @

400− --

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

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

402 -- overflow or underflow checks are performed.

396 -- overflow or underflow checks are performed.

403 --

397 --

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

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

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

407 --

400 --

408− -- @

409− --

410 -- /Pre-release/

401 -- /Pre-release/

411 --

402 --

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

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

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

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

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

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

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

417 --

408 --

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)

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

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

424 --

411 --

425− -- @

426− --

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

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

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

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

429 --

414 --

430− -- @

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

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

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

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

433 --

417 --

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

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

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

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

436 --

420 --

437− -- @

438− --

439 -- /Pre-release/

421 -- /Pre-release/

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

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

441

423

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

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

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

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

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

447 --

429 --

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)

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

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

454 --

432 --

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))

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

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

457 --

435 --

458− -- @

459− --

460 -- /Pre-release/

436 -- /Pre-release/

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

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

462

438

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

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

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

466 -- comes before or after @from@.

442 -- comes before or after @from@.

467 --

443 --

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)

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

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

474 --

446 --

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

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

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

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

477 --

449 --

478− -- @

479− --

480 -- /Pre-release/

450 -- /Pre-release/

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

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

482

452