@@ -86,9 +86,12 @@ import Prelude
86-- @from@ and incrementing every time by @stride@. For 'Bounded' types, after
86-- @from@ and incrementing every time by @stride@. For 'Bounded' types, after
87-- the value overflows it keeps enumerating in a cycle:
87-- the value overflows it keeps enumerating in a cycle:
89-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromStepNum (255::Word8,1)
90-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromStepNum (255::Word8,1)
90-- [255,0,1,2,3,4,5,6,7,8]
91-- [255,0,1,2,3,4,5,6,7,8]
92-- The implementation is numerically stable for floating point values.
95-- The implementation is numerically stable for floating point values.
94-- Note 'enumerateFromStepIntegral' is faster for integrals.
97-- Note 'enumerateFromStepIntegral' is faster for integrals.
@@ -114,14 +117,18 @@ enumerateFromStepNum = Unfold step inject
115-- | Same as 'enumerateFromStepNum (from, next)' using a stride of @next - from@:
118-- | Same as 'enumerateFromStepNum (from, next)' using a stride of @next - from@:
117−-- >>> enumerateFromThenNum =
120+-- @
118−-- lmap (\(from, next) -> (from, next - from)) enumerateFromStepNum
121+-- >>> enumerateFromThenNum = lmap (\(from, next) -> (from, next - from)) Unfold.enumerateFromStepNum
122−-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromThenNum (255::Word8,0)
127+-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold enumerateFromThenNum (255::Word8,0)
123-- [255,0,1,2,3,4,5,6,7,8]
128-- [255,0,1,2,3,4,5,6,7,8]
125-- The implementation is numerically stable for floating point values.
132-- The implementation is numerically stable for floating point values.
127-- Note that 'enumerateFromThenIntegral' is faster for integrals.
134-- Note that 'enumerateFromThenIntegral' is faster for integrals.
@@ -142,12 +149,22 @@ enumerateFromThenNum =
143-- | Same as 'enumerateFromStepNum' using a stride of 1:
150-- | Same as 'enumerateFromStepNum' using a stride of 1:
145−-- >>> enumerateFromNum = lmap (\from -> (from, 1)) enumerateFromStepNum
153+-- >>> enumerateFromNum = lmap (\from -> (from, 1)) Unfold.enumerateFromStepNum
154+-- >>> Stream.toList $ Stream.take 6 $ Stream.unfold enumerateFromNum (0.9)
155+-- [0.9,1.9,2.9,3.9,4.9,5.9]
147-- Also, same as 'enumerateFromThenNum' using a stride of 1 but see the note in
159-- Also, same as 'enumerateFromThenNum' using a stride of 1 but see the note in
148-- 'enumerateFromThenNum' about the loss of precision:
160-- 'enumerateFromThenNum' about the loss of precision:
150−-- >>> enumerateFromNum = lmap (\from -> (from, from + 1)) enumerateFromThenNum
163+-- >>> enumerateFromNum = lmap (\from -> (from, from + 1)) Unfold.enumerateFromThenNum
164+-- >>> Stream.toList $ Stream.take 6 $ Stream.unfold enumerateFromNum (0.9)
165+-- [0.9,1.9,2.9,3.8999999999999995,4.8999999999999995,5.8999999999999995]
152-- /Internal/
169-- /Internal/
@@ -265,7 +282,11 @@ enumerateFromThenFractional = enumerateFromThenNum
265-- | Same as 'enumerateFromStepNum' with a step of 1 and enumerating up to the
282-- | Same as 'enumerateFromStepNum' with a step of 1 and enumerating up to the
266-- specified upper limit rounded to the nearest integral value:
283-- specified upper limit rounded to the nearest integral value:
268−-- >>> enumerateFromToFractional =
286+-- >>> Stream.toList $ Stream.unfold Unfold.enumerateFromToFractional (0.1, 6.3)
287+-- [0.1,1.1,2.1,3.1,4.1,5.1,6.1]
270-- /Internal/
291-- /Internal/