@@ -86,9 +86,12 @@ import Prelude
8686-- @from@ and incrementing every time by @stride@. For 'Bounded' types, after
8787-- the value overflows it keeps enumerating in a cycle:
8888--
89+-- @
8990-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromStepNum (255::Word8,1)
9091-- [255,0,1,2,3,4,5,6,7,8]
9192--
93+-- @
94+--
9295-- The implementation is numerically stable for floating point values.
9396--
9497-- Note 'enumerateFromStepIntegral' is faster for integrals.
@@ -114,14 +117,18 @@ enumerateFromStepNum = Unfold step inject
114117
115118-- | Same as 'enumerateFromStepNum (from, next)' using a stride of @next - from@:
116119--
117−-- >>> enumerateFromThenNum =
118−-- lmap (\(from, next) -> (from, next - from)) enumerateFromStepNum
120+-- @
121+-- >>> enumerateFromThenNum = lmap (\(from, next) -> (from, next - from)) Unfold.enumerateFromStepNum
119122--
120−-- Example:
123+-- @
121124--
122−-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold Unfold.enumerateFromThenNum (255::Word8,0)
125+-- Example:
126+-- @
127+-- >>> Stream.toList $ Stream.take 10 $ Stream.unfold enumerateFromThenNum (255::Word8,0)
123128-- [255,0,1,2,3,4,5,6,7,8]
124129--
130+-- @
131+--
125132-- The implementation is numerically stable for floating point values.
126133--
127134-- Note that 'enumerateFromThenIntegral' is faster for integrals.
@@ -142,12 +149,22 @@ enumerateFromThenNum =
142149
143150-- | Same as 'enumerateFromStepNum' using a stride of 1:
144151--
145−-- >>> enumerateFromNum = lmap (\from -> (from, 1)) enumerateFromStepNum
152+-- @
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]
156+--
157+-- @
146158--
147159-- Also, same as 'enumerateFromThenNum' using a stride of 1 but see the note in
148160-- 'enumerateFromThenNum' about the loss of precision:
149161--
150−-- >>> enumerateFromNum = lmap (\from -> (from, from + 1)) enumerateFromThenNum
162+-- @
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]
166+--
167+-- @
151168--
152169-- /Internal/
153170--
@@ -265,7 +282,11 @@ enumerateFromThenFractional = enumerateFromThenNum
265282-- | Same as 'enumerateFromStepNum' with a step of 1 and enumerating up to the
266283-- specified upper limit rounded to the nearest integral value:
267284--
268−-- >>> enumerateFromToFractional =
285+-- @
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]
288+--
289+-- @
269290--
270291-- /Internal/
271292--