@@ -23,32 +23,39 @@ module Streamly.Internal.Data.Unfold.Enumeration
2323 (
2424 Enumerable (..)
2525
26− -- ** Enumerate Num
27− , enumerateFromStepNum
28− , numFrom
29− , numFromThen
26+ -- ** Enumerate 'Num' Types
27+ , enumerateFromNum
28+ , enumerateFromThenNum
3029
31− -- ** Enumerating 'Bounded' 'Integral' Types
30+ -- ** Enumerating 'Bounded Integral' Types
31+ , enumerateFromIntegralBounded
32+ , enumerateFromThenIntegralBounded
33+ , enumerateFromToIntegralBounded
34+ , enumerateFromThenToIntegralBounded
35+
36+ -- ** Enumerating 'Unbounded Integral' Types
3237 , enumerateFromIntegral
3338 , enumerateFromThenIntegral
34−
35− -- ** Enumerating 'Integral' Types
3639 , enumerateFromToIntegral
3740 , enumerateFromThenToIntegral
3841
39− -- ** Enumerating unbounded 'Integral' Types
40− , enumerateFromStepIntegral
42+ -- ** Enumerating 'Small Integral' Types
43+ , enumerateFromSmall
44+ , enumerateFromThenSmall
45+ , enumerateFromToSmall
46+ , enumerateFromThenToSmall
4147
4248 -- ** Enumerating 'Fractional' Types
4349 , enumerateFromFractional
44− , enumerateFromToFractional
4550 , enumerateFromThenFractional
51+ , enumerateFromToFractional
4652 , enumerateFromThenToFractional
4753 )
4854where
4955
5056#include "inline.hs"
5157import Data.Fixed
58+import Data.Bifunctor (bimap)
5259import Data.Int
5360import Data.Ratio
5461import Data.Word
@@ -64,36 +71,102 @@ import Prelude
6471-- Enumeration of Num
6572------------------------------------------------------------------------------
6673
67−-- | Generate an infinite stream starting from a starting value with increments
68−-- of the given stride. The implementation is numerically stable for floating
74+-- | Generate an infinite stream starting from a starting value with default
75+-- stride of value 1. The implementation is numerically stable for floating
6976-- point values.
7077--
7178-- Note 'enumerateFromStepIntegral' is faster for integrals.
7279--
7380-- /Pre-release/
7481--
75−{-# INLINE enumerateFromStepNum #-}
76−enumerateFromStepNum :: (Monad m, Num a) => a -> Unfold m a a
77−enumerateFromStepNum stride = Unfold step inject
82+{-# INLINE enumerateFromNum #-}
83+enumerateFromNum :: (Monad m, Num a) => Unfold m a a
84+enumerateFromNum = Unfold step inject
7885
7986 where
8087
81− inject !from = return (from, 0)
88+ inject !from = return (from, 1, 0)
8289
8390 {-# INLINE_LATE step #-}
84− step (from, !i) = return $ (Yield $! (from + i * stride)) $! (from, i + 1)
91+ step (from, stride, i) =
92+ return $
93+ (Yield $! (from + i * stride)) $! (from, stride, i + 1)
94+
95+-- | Generate an infinite stream starting from a from and next values with
96+-- stride of (next-from). The implementation is numerically stable for
97+-- floating point values.
98+--
99+-- Note 'enumerateFromStepIntegral' is faster for integrals.
100+--
101+-- /Pre-release/
102+--
103+{-# INLINE enumerateFromThenNum #-}
104+enumerateFromThenNum :: (Monad m, Num a) => Unfold m (a, a) a
105+enumerateFromThenNum = Unfold step inject
106+
107+ where
108+
109+ inject (!from, !next) = return (from, next - from, 0)
110+
111+ {-# INLINE_LATE step #-}
112+ step (from, stride, i) =
113+ return $
114+ (Yield $! (from + i * stride)) $! (from, stride, i + 1)
115+
116+-- | Generate a finite stream starting from a from and next values with
117+-- stride of (next-from) till to value. The implementation is numerically
118+-- stable for floating point values.
119+--
120+-- Note 'enumerateFromStepIntegral' is faster for integrals.
121+--
122+-- /Pre-release/
123+--
124+{-# INLINE enumerateFromThenToNumBounded #-}
125+enumerateFromThenToNumBounded :: (Monad m, Ord a, Fractional a) =>
126+ Unfold m (a, a, a) a
127+enumerateFromThenToNumBounded = Unfold step inject
128+
129+ where
130+
131+ inject (!from, !next, !to) = return (from, next - from, to, 0)
85132
86−-- | @numFrom = enumerateFromStepNum 1@
133+ {-# INLINE_LATE step #-}
134+ step (from, stride, to, !i) = return $
135+ if stride == 0
136+ then if from <= to then Yield from $! (from, stride, to, i + 1) else Stop
137+ else
138+ if stride > 0
139+ then
140+ if (from + i * stride) <= to + stride / 2
141+ then (Yield $! (from + i * stride)) $! (from, stride, to, i + 1)
142+ else Stop
143+ else
144+ if (from + i * stride) >= to + stride / 2
145+ then (Yield $! (from + i * stride)) $! (from, stride, to, i + 1)
146+ else Stop
147+
148+-- | Generate a finite stream starting from a from till to value.
149+-- stride of value 1 will be used. The implementation is numerically
150+-- stable for floating point values.
151+--
152+-- Note 'enumerateFromStepIntegralBounded' is faster for integrals.
87153--
88154-- /Pre-release/
89155--
90−{-# INLINE_NORMAL numFrom #-}
91−numFrom :: (Monad m, Num a) => Unfold m a a
92−numFrom = enumerateFromStepNum 1
156+{-# INLINE enumerateFromToNumBounded #-}
157+enumerateFromToNumBounded :: (Monad m, Ord a, Fractional a) =>
158+ Unfold m (a, a) a
159+enumerateFromToNumBounded = Unfold step inject
160+
161+ where
93162
94−{-# INLINE_NORMAL numFromThen #-}
95−numFromThen :: (Monad m, Num a) => a -> Unfold m a a
96−numFromThen = enumerateFromStepNum
163+ inject (!from, !to) = return (from, 1, to, 0)
164+
165+ {-# INLINE_LATE step #-}
166+ step (from, !stride, to, !i) = return $
167+ if (from + i * stride) <= to + stride / 2
168+ then (Yield $! (from + i * stride)) $! (from, stride, to, i + 1)
169+ else Stop
97170
98171------------------------------------------------------------------------------
99172-- Enumeration of Integrals
@@ -105,55 +178,159 @@ numFromThen = enumerateFromStepNum
105178enumerateFromStepIntegral :: (Integral a, Monad m) => Unfold m (a, a) a
106179enumerateFromStepIntegral = Unfold step inject
107180 where
108− inject (from, stride) = from `seq` stride `seq` return (from, stride)
181+ inject (from, next) = from `seq` next `seq` return (from, next - from)
109182 {-# INLINE_LATE step #-}
110183 step (x, stride) = return $ Yield x $! (x + stride, stride)
111184
112−-- We are assuming that "to" is constrained by the type to be within
113−-- max/min bounds.
114−{-# INLINE enumerateFromToIntegral #-}
115−enumerateFromToIntegral :: (Monad m, Integral a) => a -> Unfold m a a
116−enumerateFromToIntegral to =
117− takeWhile (<= to) $ supplySecond 1 enumerateFromStepIntegral
118−
119−{-# INLINE enumerateFromThenToIntegral #-}
120−enumerateFromThenToIntegral :: (Monad m, Integral a) => a -> a -> Unfold m a a
121−enumerateFromThenToIntegral stride to =
122− takeWhile (<= to) $ supplySecond stride enumerateFromStepIntegral
123−
185+-- | Can be used to enumerate bounded integrals from starting from with
186+-- stride of (next-from) . This check for overflow or underflow for
187+-- bounded integrals.
188+-- /Pre-release/
189+--
190+{-# INLINE_NORMAL enumerateFromStepIntegralBounded #-}
191+enumerateFromStepIntegralBounded ::
192+ forall a m. (Integral a, Bounded a, Monad m) =>
193+ Unfold m (a, a) a
194+enumerateFromStepIntegralBounded = Unfold step inject
195+ where
196+ inject (from, next) =
197+ from `seq` next `seq` return (from, next - from)
198+ {-# INLINE_LATE step #-}
199+ step (x, stride) = return $
200+ if stride == 0
201+ then
202+ Yield x $! (x, stride)
203+
204+ else
205+ if stride > 0
206+ then
207+ if x <= (maxBound :: a)
208+ then Yield x $! (x + stride, stride)
209+ else Stop
210+ else
211+ if x >= (minBound :: a)
212+ then Yield x $! (x + stride, stride)
213+ else Stop
214+
215+-- | Can be used to enumerate bounded integrals from starting from with
216+-- stride of (next-from) till to value. This check for overflow or underflow
217+-- for bounded integrals.
218+-- /Pre-release/
219+--
220+{-# INLINE_NORMAL enumerateFromToStepIntegralBounded #-}
221+enumerateFromToStepIntegralBounded ::
222+ forall a m. (Integral a, Bounded a, Monad m) =>
223+ Unfold m (a, a, a) a
224+enumerateFromToStepIntegralBounded = Unfold step inject
225+ where
226+ inject (from, next, to) =
227+ from `seq` next `seq` to `seq` return (from, next - from, to)
228+ {-# INLINE_LATE step #-}
229+ step (x, stride, to) = return $
230+ if stride == 0
231+ then
232+ if x <= to then Yield x $! (x, stride, to) else Stop
233+
234+ else
235+ if stride > 0
236+ then
237+ if x <= to && x <= (maxBound :: a)
238+ then Yield x $! (x + stride, stride, to)
239+ else Stop
240+ else
241+ if x >= to && x >= (minBound :: a)
242+ then Yield x $! (x + stride, stride, to)
243+ else Stop
244+
245+-- | Can be used to enumerate unbounded integrals. Startting with value from
246+-- with stride of next-from till value of to.
247+-- /Pre-release/
248+--
249+{-# INLINE_NORMAL enumerateFromToStepIntegral #-}
250+enumerateFromToStepIntegral :: (Integral a, Monad m) =>
251+ Unfold m (a, a, a) a
252+enumerateFromToStepIntegral = Unfold step inject
253+ where
254+ inject (from, next, to) =
255+ from `seq` next `seq` to `seq` return (from, next - from, to)
256+ {-# INLINE_LATE step #-}
257+ step (x, stride, to) = return $
258+ if stride == 0
259+ then
260+ if x <= to then Yield x $! (x, stride, to) else Stop
261+
262+ else
263+ if stride > 0
264+ then
265+ if x <= to
266+ then Yield x $! (x + stride, stride, to)
267+ else Stop
268+ else
269+ if x >= to
270+ then Yield x $! (x + stride, stride, to)
271+ else Stop
272+
273+-- Enumerate Unbounded Integrals ----------------------------------------------
124274{-# INLINE enumerateFromIntegral #-}
125−enumerateFromIntegral :: (Monad m, Integral a, Bounded a) => Unfold m a a
126−enumerateFromIntegral = enumerateFromToIntegral maxBound
275+enumerateFromIntegral :: (Monad m, Integral a) => Unfold m a a
276+enumerateFromIntegral = supplyNextFromStride (+ 1) enumerateFromStepIntegral
127277
128278{-# INLINE enumerateFromThenIntegral #-}
129−enumerateFromThenIntegral :: (Monad m, Integral a, Bounded a) => a -> Unfold m a a
130−enumerateFromThenIntegral stride = enumerateFromThenToIntegral stride maxBound
279+enumerateFromThenIntegral :: (Monad m, Integral a ) => Unfold m (a, a) a
280+enumerateFromThenIntegral = enumerateFromStepIntegral
281+
282+{-# INLINE enumerateFromToIntegral #-}
283+enumerateFromToIntegral :: (Monad m, Integral a) => Unfold m (a, a) a
284+enumerateFromToIntegral = supplyMiddle (+ 1) enumerateFromToStepIntegral
285+
286+{-# INLINE enumerateFromThenToIntegral #-}
287+enumerateFromThenToIntegral :: (Monad m, Integral a) => Unfold m (a, a, a) a
288+enumerateFromThenToIntegral = enumerateFromToStepIntegral
289+
290+-- Enumerate Bounded Integrals ------------------------------------------------
291+{-# INLINE enumerateFromIntegralBounded #-}
292+enumerateFromIntegralBounded :: (Monad m, Bounded a, Integral a) =>
293+ Unfold m a a
294+enumerateFromIntegralBounded =
295+ supplySecondThird (+ 1) maxBound enumerateFromToStepIntegralBounded
296+
297+{-# INLINE enumerateFromThenIntegralBounded #-}
298+enumerateFromThenIntegralBounded :: (Monad m, Bounded a, Integral a ) =>
299+ Unfold m (a, a) a
300+enumerateFromThenIntegralBounded = enumerateFromStepIntegralBounded
301+
302+{-# INLINE enumerateFromToIntegralBounded #-}
303+enumerateFromToIntegralBounded :: (Monad m, Integral a, Bounded a) =>
304+ Unfold m (a, a) a
305+enumerateFromToIntegralBounded =
306+ supplyMiddle (+ 1) enumerateFromToStepIntegralBounded
307+
308+{-# INLINE enumerateFromThenToIntegralBounded #-}
309+enumerateFromThenToIntegralBounded :: (Monad m, Integral a, Bounded a) =>
310+ Unfold m (a, a, a) a
311+enumerateFromThenToIntegralBounded = enumerateFromToStepIntegralBounded
131312
132313------------------------------------------------------------------------------
133314-- Enumeration of Fractionals
134315------------------------------------------------------------------------------
135316
136−-- | /Internal/
137−--
138−-- > enumerateFromToFractional to = takeWhile (<= to + 1 / 2) $ enumerateFromStepNum 1
139−--
140−{-# INLINE_NORMAL enumerateFromToFractional #-}
141−enumerateFromToFractional :: (Monad m, Fractional a, Ord a) => a -> Unfold m a a
142−enumerateFromToFractional to =
143− takeWhile (<= to + 1 / 2) $ enumerateFromStepNum 1
144−
145317{-# INLINE_NORMAL enumerateFromFractional #-}
146318enumerateFromFractional :: (Monad m, Fractional a) => Unfold m a a
147−enumerateFromFractional = enumerateFromStepNum 1
148−
149−{-# INLINE_NORMAL enumerateFromThenToFractional #-}
150−enumerateFromThenToFractional :: (Monad m, Fractional a, Ord a) => a -> a -> Unfold m a a
151−enumerateFromThenToFractional stride to =
152− takeWhile (<= to + 1 / 2) $ enumerateFromStepNum stride
319+enumerateFromFractional = enumerateFromNum
153320
154321{-# INLINE_NORMAL enumerateFromThenFractional #-}
155−enumerateFromThenFractional :: (Monad m, Fractional a) => a -> Unfold m a a
156−enumerateFromThenFractional = enumerateFromStepNum
322+enumerateFromThenFractional :: (Monad m, Fractional a) => Unfold m (a, a) a
323+enumerateFromThenFractional = enumerateFromThenNum
324+
325+{-# INLINE_NORMAL enumerateFromToFractional #-}
326+enumerateFromToFractional :: (Monad m, Fractional a, Ord a) =>
327+ Unfold m (a, a) a
328+enumerateFromToFractional = enumerateFromToNumBounded
329+
330+{-# INLINE_NORMAL enumerateFromThenToFractional #-}
331+enumerateFromThenToFractional :: (Monad m, Fractional a, Ord a) =>
332+ Unfold m (a, a, a) a
333+enumerateFromThenToFractional = enumerateFromThenToNumBounded
157334
158335-------------------------------------------------------------------------------
159336-- Enumerable type class
@@ -212,7 +389,7 @@ class Enum a => Enumerable a where
212389-- @
213390--
214391-- /Pre-release/
215− enumerateFromTo :: Monad m => a -> Unfold m a a
392+ enumerateFromTo :: Monad m => Unfold m (a, a) a
216393
217394-- @enumerateFromThen from then@ generates a stream whose first element
218395-- is @from@ and the successive elements are
@@ -231,7 +408,7 @@ class Enum a => Enumerable a where
231408-- @
232409--
233410-- /Pre-release/
234− enumerateFromThen :: Monad m => a -> Unfold m a a
411+ enumerateFromThen :: Monad m => Unfold m (a, a) a
235412
236413-- @enumerateFromThenTo from then to@ generates a finite stream whose
237414-- first element is @from@ and the successive elements are in
@@ -249,7 +426,112 @@ class Enum a => Enumerable a where
249426-- @
250427--
251428-- /Pre-release/
252− enumerateFromThenTo :: Monad m => a-> a -> Unfold m a a
429+ enumerateFromThenTo :: Monad m => Unfold m (a, a, a) a
430+
431+-------------------------------------------------------------------------------
432+-- Enumeration of Enum types not larger than Int
433+-------------------------------------------------------------------------------
434+
435+-- Enumerate from given starting Enum value 'from' with stride of 1 till
436+-- maxBound
437+-- /Pre-release/
438+--
439+{-# INLINE enumerateFromSmall #-}
440+enumerateFromSmall :: forall a m. (Monad m, Bounded a, Enum a) => Unfold m a a
441+enumerateFromSmall = map toEnum $
442+ Unfold step inject
443+ where
444+ inject from =
445+ fromEnum from
446+ `seq` return (fromEnum from, 1, fromEnum (maxBound :: a))
447+ {-# INLINE_LATE step #-}
448+ step (x, stride, to) = return $
449+ if x <= to then Yield x $! (x + stride, stride, to) else Stop
450+
451+-- Enumerate from given starting Enum value 'from' and next Enum value 'next'
452+-- with stride of (fromEnum next - fromEnum from) till maxBound.
453+-- /Pre-release/
454+--
455+{-# INLINE enumerateFromThenSmall #-}
456+enumerateFromThenSmall :: forall a m. (Monad m, Bounded a, Enum a) =>
457+ Unfold m (a, a) a
458+enumerateFromThenSmall = map toEnum $
459+ Unfold step inject
460+ where
461+ inject (from, next) =
462+ fromEnum from
463+ `seq` fromEnum next
464+ `seq` return
465+ ( fromEnum from
466+ , fromEnum next - fromEnum from
467+ , fromEnum (maxBound :: a)
468+ )
469+ {-# INLINE_LATE step #-}
470+ step (x, stride, to) = return $
471+ if stride == 0
472+ then
473+ if x <= to then Yield x $! (x, stride, to) else Stop
474+
475+ else
476+ if stride > 0
477+ then
478+ if x <= to
479+ then Yield x $! (x + stride, stride, to)
480+ else Stop
481+ else
482+ if x >= 0
483+ then Yield x $! (x + stride, stride, to)
484+ else Stop
485+
486+-- Enumerate from given starting Enum value 'from' and to Enum value 'to'
487+-- with stride of 1 till to value.
488+-- /Pre-release/
489+--
490+{-# INLINE enumerateFromToSmall #-}
491+enumerateFromToSmall :: (Monad m, Enum a) => Unfold m (a, a) a
492+enumerateFromToSmall = map toEnum $
493+ Unfold step inject
494+ where
495+ inject (from, to) =
496+ fromEnum from
497+ `seq` fromEnum to
498+ `seq` return (fromEnum from, 1, fromEnum to)
499+ {-# INLINE_LATE step #-}
500+ step (x, stride, to) = return $
501+ if x <= to then Yield x $! (x + stride, stride, to) else Stop
502+
503+-- Enumerate from given starting Enum value 'from' and then Enum value 'next'
504+-- and to Enum value 'to' with stride of (fromEnum next - fromEnum from)
505+-- till to value.
506+-- /Pre-release/
507+--
508+{-# INLINE enumerateFromThenToSmall #-}
509+enumerateFromThenToSmall :: (Monad m, Enum a) => Unfold m (a, a, a) a
510+enumerateFromThenToSmall = map toEnum $
511+ Unfold step inject
512+ where
513+ inject (from, next, to) =
514+ fromEnum from
515+ `seq` fromEnum next
516+ `seq` fromEnum to
517+ `seq` return
518+ (fromEnum from, fromEnum next - fromEnum from, fromEnum to)
519+ {-# INLINE_LATE step #-}
520+ step (x, stride, to) = return $
521+ if stride == 0
522+ then
523+ if x <= to then Yield x $! (x, stride, to) else Stop
524+
525+ else
526+ if stride > 0
527+ then
528+ if x <= to
529+ then Yield x $! (x + stride, stride, to)
530+ else Stop
531+ else
532+ if x >= 0 && x >= to
533+ then Yield x $! (x + stride, stride, to)
534+ else Stop
253535
254536-------------------------------------------------------------------------------
255537-- Enumerable Instances
@@ -259,13 +541,13 @@ class Enum a => Enumerable a where
259541#define ENUMERABLE_BOUNDED_SMALL(SMALL_TYPE) \
260542instance Enumerable SMALL_TYPE where { \
261543 {-# INLINE enumerateFrom #-}; \
262− enumerateFrom = undefined; \
544+ enumerateFrom = enumerateFromSmall; \
263545 {-# INLINE enumerateFromThen #-}; \
264− enumerateFromThen = undefined; \
546+ enumerateFromThen = enumerateFromThenSmall; \
265547 {-# INLINE enumerateFromTo #-}; \
266− enumerateFromTo = undefined; \
548+ enumerateFromTo = enumerateFromToSmall; \
267549 {-# INLINE enumerateFromThenTo #-}; \
268− enumerateFromThenTo = undefined }
550+ enumerateFromThenTo = enumerateFromThenToSmall }
269551
270552ENUMERABLE_BOUNDED_SMALL(())
271553ENUMERABLE_BOUNDED_SMALL(Bool)
@@ -273,16 +555,16 @@ ENUMERABLE_BOUNDED_SMALL(Ordering)
273555ENUMERABLE_BOUNDED_SMALL(Char)
274556
275557-- For bounded Integral Enum types, may be larger than Int.
276−#define ENUMERABLE_BOUNDED_INTEGRAL(INTEGRAL_TYPE) \
277−instance Enumerable INTEGRAL_TYPE where { \
278− {-# INLINE enumerateFrom #-}; \
279− enumerateFrom = enumerateFromIntegral; \
280− {-# INLINE enumerateFromThen #-}; \
281− enumerateFromThen = enumerateFromThenIntegral; \
282− {-# INLINE enumerateFromTo #-}; \
283− enumerateFromTo = enumerateFromToIntegral; \
284− {-# INLINE enumerateFromThenTo #-}; \
285− enumerateFromThenTo = enumerateFromThenToIntegral }
558+#define ENUMERABLE_BOUNDED_INTEGRAL(INTEGRAL_TYPE) \
559+instance Enumerable INTEGRAL_TYPE where { \
560+ {-# INLINE enumerateFrom #-}; \
561+ enumerateFrom = enumerateFromIntegralBounded; \
562+ {-# INLINE enumerateFromThen #-}; \
563+ enumerateFromThen = enumerateFromThenIntegralBounded; \
564+ {-# INLINE enumerateFromTo #-}; \
565+ enumerateFromTo = enumerateFromToIntegralBounded; \
566+ {-# INLINE enumerateFromThenTo #-}; \
567+ enumerateFromThenTo = enumerateFromThenToIntegralBounded }
286568
287569ENUMERABLE_BOUNDED_INTEGRAL(Int)
288570ENUMERABLE_BOUNDED_INTEGRAL(Int8)
@@ -299,10 +581,9 @@ ENUMERABLE_BOUNDED_INTEGRAL(Word64)
299581#define ENUMERABLE_UNBOUNDED_INTEGRAL(INTEGRAL_TYPE) \
300582instance Enumerable INTEGRAL_TYPE where { \
301583 {-# INLINE enumerateFrom #-}; \
302− enumerateFrom = supplySecond 1 enumerateFromStepIntegral; \
584+ enumerateFrom = enumerateFromIntegral; \
303585 {-# INLINE enumerateFromThen #-}; \
304− enumerateFromThen next = \
305− lmap (\from -> (from, next - from)) enumerateFromStepIntegral; \
586+ enumerateFromThen = enumerateFromThenIntegral; \
306587 {-# INLINE enumerateFromTo #-}; \
307588 enumerateFromTo = enumerateFromToIntegral; \
308589 {-# INLINE enumerateFromThenTo #-}; \
@@ -329,10 +610,18 @@ ENUMERABLE_FRACTIONAL((Ratio a),Integral a)
329610
330611instance Enumerable a => Enumerable (Identity a) where
331612 {-# INLINE enumerateFrom #-}
332− enumerateFrom = map Identity $ lmap runIdentity enumerateFrom
613+ enumerateFrom =
614+ map Identity $ lmap runIdentity enumerateFrom
333615 {-# INLINE enumerateFromThen #-}
334− enumerateFromThen = undefined
616+ enumerateFromThen =
617+ map Identity $ lmap (bimap runIdentity runIdentity) enumerateFromThen
335618 {-# INLINE enumerateFromTo #-}
336− enumerateFromTo = undefined
619+ enumerateFromTo =
620+ map Identity $ lmap (bimap runIdentity runIdentity) enumerateFromThen
337621 {-# INLINE enumerateFromThenTo #-}
338− enumerateFromThenTo = undefined
622+ enumerateFromThenTo =
623+ map Identity $
624+ lmap
625+ (\(from, next, to) ->
626+ (runIdentity from, runIdentity next, runIdentity to))
627+ enumerateFromThenTo