@@ -23,32 +23,39 @@ module Streamly.Internal.Data.Unfold.Enumeration
24 Enumerable (..)
24 Enumerable (..)
26− -- ** Enumerate Num
26+ -- ** Enumerate 'Num' Types
27− , enumerateFromStepNum
27+ , enumerateFromNum
28− , numFrom
28+ , enumerateFromThenNum
31− -- ** Enumerating 'Bounded' 'Integral' Types
30+ -- ** Enumerating 'Bounded Integral' Types
31+ , enumerateFromIntegralBounded
32+ , enumerateFromThenIntegralBounded
33+ , enumerateFromToIntegralBounded
34+ , enumerateFromThenToIntegralBounded
36+ -- ** Enumerating 'Unbounded Integral' Types
32 , enumerateFromIntegral
37 , enumerateFromIntegral
33 , enumerateFromThenIntegral
38 , enumerateFromThenIntegral
35− -- ** Enumerating 'Integral' Types
36 , enumerateFromToIntegral
39 , enumerateFromToIntegral
37 , enumerateFromThenToIntegral
40 , enumerateFromThenToIntegral
39− -- ** Enumerating unbounded 'Integral' Types
42+ -- ** Enumerating 'Small Integral' Types
40− , enumerateFromStepIntegral
43+ , enumerateFromSmall
44+ , enumerateFromThenSmall
45+ , enumerateFromToSmall
46+ , enumerateFromThenToSmall
42 -- ** Enumerating 'Fractional' Types
48 -- ** Enumerating 'Fractional' Types
43 , enumerateFromFractional
49 , enumerateFromFractional
44− , enumerateFromToFractional
45 , enumerateFromThenFractional
50 , enumerateFromThenFractional
51+ , enumerateFromToFractional
46 , enumerateFromThenToFractional
52 , enumerateFromThenToFractional
50#include "inline.hs"
56#include "inline.hs"
51import Data.Fixed
57import Data.Fixed
58+import Data.Bifunctor (bimap)
52import Data.Int
59import Data.Int
53import Data.Ratio
60import Data.Ratio
54import Data.Word
61import Data.Word
@@ -64,36 +71,102 @@ import Prelude
64-- Enumeration of Num
71-- Enumeration of Num
65------------------------------------------------------------------------------
72------------------------------------------------------------------------------
67−-- | Generate an infinite stream starting from a starting value with increments
74+-- | Generate an infinite stream starting from a starting value with default
68−-- of the given stride. The implementation is numerically stable for floating
75+-- stride of value 1. The implementation is numerically stable for floating
69-- point values.
76-- point values.
71-- Note 'enumerateFromStepIntegral' is faster for integrals.
78-- Note 'enumerateFromStepIntegral' is faster for integrals.
73-- /Pre-release/
80-- /Pre-release/
75−{-# INLINE enumerateFromStepNum #-}
82+{-# INLINE enumerateFromNum #-}
76−enumerateFromStepNum :: (Monad m, Num a) => a -> Unfold m a a
83+enumerateFromNum :: (Monad m, Num a) => Unfold m a a
77−enumerateFromStepNum stride = Unfold step inject
84+enumerateFromNum = Unfold step inject
81− inject !from = return (from, 0)
88+ inject !from = return (from, 1, 0)
83 {-# INLINE_LATE step #-}
90 {-# INLINE_LATE step #-}
91+ step (from, stride, i) =
93+ (Yield $! (from + i * stride)) $! (from, stride, i + 1)
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.
99+-- Note 'enumerateFromStepIntegral' is faster for integrals.
103+{-# INLINE enumerateFromThenNum #-}
104+enumerateFromThenNum :: (Monad m, Num a) => Unfold m (a, a) a
105+enumerateFromThenNum = Unfold step inject
109+ inject (!from, !next) = return (from, next - from, 0)
111+ {-# INLINE_LATE step #-}
112+ step (from, stride, i) =
84− step (from, !i) = return $ (Yield $! (from + i * stride)) $! (from, i + 1)
114+ (Yield $! (from + i * stride)) $! (from, stride, i + 1)
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.
120+-- Note 'enumerateFromStepIntegral' is faster for integrals.
124+{-# INLINE enumerateFromThenToNumBounded #-}
125+enumerateFromThenToNumBounded :: (Monad m, Ord a, Fractional a) =>
126+ Unfold m (a, a, a) a
127+enumerateFromThenToNumBounded = Unfold step inject
131+ inject (!from, !next, !to) = return (from, next - from, to, 0)
86−-- | @numFrom = enumerateFromStepNum 1@
133+ {-# INLINE_LATE step #-}
134+ step (from, stride, to, !i) = return $
136+ then if from <= to then Yield from $! (from, stride, to, i + 1) else Stop
140+ if (from + i * stride) <= to + stride / 2
141+ then (Yield $! (from + i * stride)) $! (from, stride, to, i + 1)
144+ if (from + i * stride) >= to + stride / 2
145+ then (Yield $! (from + i * stride)) $! (from, stride, to, i + 1)
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.
152+-- Note 'enumerateFromStepIntegralBounded' is faster for integrals.
88-- /Pre-release/
154-- /Pre-release/
90−{-# INLINE_NORMAL numFrom #-}
156+{-# INLINE enumerateFromToNumBounded #-}
157+enumerateFromToNumBounded :: (Monad m, Ord a, Fractional a) =>
91−numFrom :: (Monad m, Num a) => Unfold m a a
158+ Unfold m (a, a) a
92−numFrom = enumerateFromStepNum 1
159+enumerateFromToNumBounded = Unfold step inject
94−{-# INLINE_NORMAL numFromThen #-}
163+ inject (!from, !to) = return (from, 1, to, 0)
95−numFromThen :: (Monad m, Num a) => a -> Unfold m a a
164+
96−numFromThen = enumerateFromStepNum
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)
98------------------------------------------------------------------------------
171------------------------------------------------------------------------------
99-- Enumeration of Integrals
172-- Enumeration of Integrals
@@ -105,55 +178,159 @@ numFromThen = enumerateFromStepNum
105enumerateFromStepIntegral :: (Integral a, Monad m) => Unfold m (a, a) a
178enumerateFromStepIntegral :: (Integral a, Monad m) => Unfold m (a, a) a
106enumerateFromStepIntegral = Unfold step inject
179enumerateFromStepIntegral = Unfold step inject
108− inject (from, stride) = from `seq` stride `seq` return (from, stride)
181+ inject (from, next) = from `seq` next `seq` return (from, next - from)
109 {-# INLINE_LATE step #-}
182 {-# INLINE_LATE step #-}
110 step (x, stride) = return $ Yield x $! (x + stride, stride)
183 step (x, stride) = return $ Yield x $! (x + stride, stride)
112−-- We are assuming that "to" is constrained by the type to be within
185+-- | Can be used to enumerate bounded integrals from starting from with
113−-- max/min bounds.
186+-- stride of (next-from) . This check for overflow or underflow for
114−{-# INLINE enumerateFromToIntegral #-}
187+-- bounded integrals.
115−enumerateFromToIntegral :: (Monad m, Integral a) => a -> Unfold m a a
188+-- /Pre-release/
116−enumerateFromToIntegral to =
189+--
117− takeWhile (<= to) $ supplySecond 1 enumerateFromStepIntegral
190+{-# INLINE_NORMAL enumerateFromStepIntegralBounded #-}
118−
191+enumerateFromStepIntegralBounded ::
119−{-# INLINE enumerateFromThenToIntegral #-}
192+ forall a m. (Integral a, Bounded a, Monad m) =>
120−enumerateFromThenToIntegral :: (Monad m, Integral a) => a -> a -> Unfold m a a
193+ Unfold m (a, a) a
121−enumerateFromThenToIntegral stride to =
194+enumerateFromStepIntegralBounded = Unfold step inject
122− takeWhile (<= to) $ supplySecond stride enumerateFromStepIntegral
195+ where
123−
196+ inject (from, next) =
197+ from `seq` next `seq` return (from, next - from)
198+ {-# INLINE_LATE step #-}
199+ step (x, stride) = return $
202+ Yield x $! (x, stride)
207+ if x <= (maxBound :: a)
208+ then Yield x $! (x + stride, stride)
211+ if x >= (minBound :: a)
212+ then Yield x $! (x + stride, stride)
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.
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
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 $
232+ if x <= to then Yield x $! (x, stride, to) else Stop
237+ if x <= to && x <= (maxBound :: a)
238+ then Yield x $! (x + stride, stride, to)
241+ if x >= to && x >= (minBound :: a)
242+ then Yield x $! (x + stride, stride, to)
245+-- | Can be used to enumerate unbounded integrals. Startting with value from
246+-- with stride of next-from till value of to.
249+{-# INLINE_NORMAL enumerateFromToStepIntegral #-}
250+enumerateFromToStepIntegral :: (Integral a, Monad m) =>
251+ Unfold m (a, a, a) a
252+enumerateFromToStepIntegral = Unfold step inject
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 $
260+ if x <= to then Yield x $! (x, stride, to) else Stop
266+ then Yield x $! (x + stride, stride, to)
270+ then Yield x $! (x + stride, stride, to)
273+-- Enumerate Unbounded Integrals ----------------------------------------------
124{-# INLINE enumerateFromIntegral #-}
274{-# INLINE enumerateFromIntegral #-}
125−enumerateFromIntegral :: (Monad m, Integral a, Bounded a) => Unfold m a a
275+enumerateFromIntegral :: (Monad m, Integral a) => Unfold m a a
126−enumerateFromIntegral = enumerateFromToIntegral maxBound
276+enumerateFromIntegral = supplyNextFromStride (+ 1) enumerateFromStepIntegral
128{-# INLINE enumerateFromThenIntegral #-}
278{-# INLINE enumerateFromThenIntegral #-}
129−enumerateFromThenIntegral :: (Monad m, Integral a, Bounded a) => a -> Unfold m a a
279+enumerateFromThenIntegral :: (Monad m, Integral a ) => Unfold m (a, a) a
130−enumerateFromThenIntegral stride = enumerateFromThenToIntegral stride maxBound
280+enumerateFromThenIntegral = enumerateFromStepIntegral
282+{-# INLINE enumerateFromToIntegral #-}
283+enumerateFromToIntegral :: (Monad m, Integral a) => Unfold m (a, a) a
284+enumerateFromToIntegral = supplyMiddle (+ 1) enumerateFromToStepIntegral
286+{-# INLINE enumerateFromThenToIntegral #-}
287+enumerateFromThenToIntegral :: (Monad m, Integral a) => Unfold m (a, a, a) a
288+enumerateFromThenToIntegral = enumerateFromToStepIntegral
290+-- Enumerate Bounded Integrals ------------------------------------------------
291+{-# INLINE enumerateFromIntegralBounded #-}
292+enumerateFromIntegralBounded :: (Monad m, Bounded a, Integral a) =>
294+enumerateFromIntegralBounded =
295+ supplySecondThird (+ 1) maxBound enumerateFromToStepIntegralBounded
297+{-# INLINE enumerateFromThenIntegralBounded #-}
298+enumerateFromThenIntegralBounded :: (Monad m, Bounded a, Integral a ) =>
300+enumerateFromThenIntegralBounded = enumerateFromStepIntegralBounded
302+{-# INLINE enumerateFromToIntegralBounded #-}
303+enumerateFromToIntegralBounded :: (Monad m, Integral a, Bounded a) =>
305+enumerateFromToIntegralBounded =
306+ supplyMiddle (+ 1) enumerateFromToStepIntegralBounded
308+{-# INLINE enumerateFromThenToIntegralBounded #-}
309+enumerateFromThenToIntegralBounded :: (Monad m, Integral a, Bounded a) =>
310+ Unfold m (a, a, a) a
311+enumerateFromThenToIntegralBounded = enumerateFromToStepIntegralBounded
132------------------------------------------------------------------------------
313------------------------------------------------------------------------------
133-- Enumeration of Fractionals
314-- Enumeration of Fractionals
134------------------------------------------------------------------------------
315------------------------------------------------------------------------------
138−-- > enumerateFromToFractional to = takeWhile (<= to + 1 / 2) $ enumerateFromStepNum 1
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
145{-# INLINE_NORMAL enumerateFromFractional #-}
317{-# INLINE_NORMAL enumerateFromFractional #-}
146enumerateFromFractional :: (Monad m, Fractional a) => Unfold m a a
318enumerateFromFractional :: (Monad m, Fractional a) => Unfold m a a
147−enumerateFromFractional = enumerateFromStepNum 1
319+enumerateFromFractional = enumerateFromNum
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
154{-# INLINE_NORMAL enumerateFromThenFractional #-}
321{-# INLINE_NORMAL enumerateFromThenFractional #-}
155−enumerateFromThenFractional :: (Monad m, Fractional a) => a -> Unfold m a a
322+enumerateFromThenFractional :: (Monad m, Fractional a) => Unfold m (a, a) a
156−enumerateFromThenFractional = enumerateFromStepNum
323+enumerateFromThenFractional = enumerateFromThenNum
325+{-# INLINE_NORMAL enumerateFromToFractional #-}
326+enumerateFromToFractional :: (Monad m, Fractional a, Ord a) =>
328+enumerateFromToFractional = enumerateFromToNumBounded
330+{-# INLINE_NORMAL enumerateFromThenToFractional #-}
331+enumerateFromThenToFractional :: (Monad m, Fractional a, Ord a) =>
332+ Unfold m (a, a, a) a
333+enumerateFromThenToFractional = enumerateFromThenToNumBounded
158-------------------------------------------------------------------------------
335-------------------------------------------------------------------------------
159-- Enumerable type class
336-- Enumerable type class
@@ -212,7 +389,7 @@ class Enum a => Enumerable a where
214-- /Pre-release/
391-- /Pre-release/
215− enumerateFromTo :: Monad m => a -> Unfold m a a
392+ enumerateFromTo :: Monad m => Unfold m (a, a) a
217-- @enumerateFromThen from then@ generates a stream whose first element
394-- @enumerateFromThen from then@ generates a stream whose first element
218-- is @from@ and the successive elements are
395-- is @from@ and the successive elements are
@@ -231,7 +408,7 @@ class Enum a => Enumerable a where
233-- /Pre-release/
410-- /Pre-release/
234− enumerateFromThen :: Monad m => a -> Unfold m a a
411+ enumerateFromThen :: Monad m => Unfold m (a, a) a
236-- @enumerateFromThenTo from then to@ generates a finite stream whose
413-- @enumerateFromThenTo from then to@ generates a finite stream whose
237-- first element is @from@ and the successive elements are in
414-- first element is @from@ and the successive elements are in
@@ -249,7 +426,112 @@ class Enum a => Enumerable a where
251-- /Pre-release/
428-- /Pre-release/
252− enumerateFromThenTo :: Monad m => a-> a -> Unfold m a a
429+ enumerateFromThenTo :: Monad m => Unfold m (a, a, a) a
431+-------------------------------------------------------------------------------
432+-- Enumeration of Enum types not larger than Int
433+-------------------------------------------------------------------------------
435+-- Enumerate from given starting Enum value 'from' with stride of 1 till
439+{-# INLINE enumerateFromSmall #-}
440+enumerateFromSmall :: forall a m. (Monad m, Bounded a, Enum a) => Unfold m a a
441+enumerateFromSmall = map toEnum $
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
451+-- Enumerate from given starting Enum value 'from' and next Enum value 'next'
452+-- with stride of (fromEnum next - fromEnum from) till maxBound.
455+{-# INLINE enumerateFromThenSmall #-}
456+enumerateFromThenSmall :: forall a m. (Monad m, Bounded a, Enum a) =>
458+enumerateFromThenSmall = map toEnum $
461+ inject (from, next) =
466+ , fromEnum next - fromEnum from
467+ , fromEnum (maxBound :: a)
469+ {-# INLINE_LATE step #-}
470+ step (x, stride, to) = return $
473+ if x <= to then Yield x $! (x, stride, to) else Stop
479+ then Yield x $! (x + stride, stride, to)
483+ then Yield x $! (x + stride, stride, to)
486+-- Enumerate from given starting Enum value 'from' and to Enum value 'to'
487+-- with stride of 1 till to value.
490+{-# INLINE enumerateFromToSmall #-}
491+enumerateFromToSmall :: (Monad m, Enum a) => Unfold m (a, a) a
492+enumerateFromToSmall = map toEnum $
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
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)
508+{-# INLINE enumerateFromThenToSmall #-}
509+enumerateFromThenToSmall :: (Monad m, Enum a) => Unfold m (a, a, a) a
510+enumerateFromThenToSmall = map toEnum $
513+ inject (from, next, to) =
518+ (fromEnum from, fromEnum next - fromEnum from, fromEnum to)
519+ {-# INLINE_LATE step #-}
520+ step (x, stride, to) = return $
523+ if x <= to then Yield x $! (x, stride, to) else Stop
529+ then Yield x $! (x + stride, stride, to)
532+ if x >= 0 && x >= to
533+ then Yield x $! (x + stride, stride, to)
254-------------------------------------------------------------------------------
536-------------------------------------------------------------------------------
255-- Enumerable Instances
537-- Enumerable Instances
@@ -259,13 +541,13 @@ class Enum a => Enumerable a where
259#define ENUMERABLE_BOUNDED_SMALL(SMALL_TYPE) \
541#define ENUMERABLE_BOUNDED_SMALL(SMALL_TYPE) \
260instance Enumerable SMALL_TYPE where { \
542instance Enumerable SMALL_TYPE where { \
261 {-# INLINE enumerateFrom #-}; \
543 {-# INLINE enumerateFrom #-}; \
262− enumerateFrom = undefined; \
544+ enumerateFrom = enumerateFromSmall; \
263 {-# INLINE enumerateFromThen #-}; \
545 {-# INLINE enumerateFromThen #-}; \
264− enumerateFromThen = undefined; \
546+ enumerateFromThen = enumerateFromThenSmall; \
265 {-# INLINE enumerateFromTo #-}; \
547 {-# INLINE enumerateFromTo #-}; \
266− enumerateFromTo = undefined; \
548+ enumerateFromTo = enumerateFromToSmall; \
267 {-# INLINE enumerateFromThenTo #-}; \
549 {-# INLINE enumerateFromThenTo #-}; \
268− enumerateFromThenTo = undefined }
550+ enumerateFromThenTo = enumerateFromThenToSmall }
270ENUMERABLE_BOUNDED_SMALL(())
552ENUMERABLE_BOUNDED_SMALL(())
271ENUMERABLE_BOUNDED_SMALL(Bool)
553ENUMERABLE_BOUNDED_SMALL(Bool)
@@ -273,16 +555,16 @@ ENUMERABLE_BOUNDED_SMALL(Ordering)
273ENUMERABLE_BOUNDED_SMALL(Char)
555ENUMERABLE_BOUNDED_SMALL(Char)
275-- For bounded Integral Enum types, may be larger than Int.
557-- For bounded Integral Enum types, may be larger than Int.
276−#define ENUMERABLE_BOUNDED_INTEGRAL(INTEGRAL_TYPE) \
558+#define ENUMERABLE_BOUNDED_INTEGRAL(INTEGRAL_TYPE) \
277−instance Enumerable INTEGRAL_TYPE where { \
559+instance Enumerable INTEGRAL_TYPE where { \
278− {-# INLINE enumerateFrom #-}; \
560+ {-# INLINE enumerateFrom #-}; \
279− enumerateFrom = enumerateFromIntegral; \
561+ enumerateFrom = enumerateFromIntegralBounded; \
280− {-# INLINE enumerateFromThen #-}; \
562+ {-# INLINE enumerateFromThen #-}; \
281− enumerateFromThen = enumerateFromThenIntegral; \
563+ enumerateFromThen = enumerateFromThenIntegralBounded; \
282− {-# INLINE enumerateFromTo #-}; \
564+ {-# INLINE enumerateFromTo #-}; \
283− enumerateFromTo = enumerateFromToIntegral; \
565+ enumerateFromTo = enumerateFromToIntegralBounded; \
284− {-# INLINE enumerateFromThenTo #-}; \
566+ {-# INLINE enumerateFromThenTo #-}; \
285− enumerateFromThenTo = enumerateFromThenToIntegral }
567+ enumerateFromThenTo = enumerateFromThenToIntegralBounded }
287ENUMERABLE_BOUNDED_INTEGRAL(Int)
569ENUMERABLE_BOUNDED_INTEGRAL(Int)
288ENUMERABLE_BOUNDED_INTEGRAL(Int8)
570ENUMERABLE_BOUNDED_INTEGRAL(Int8)
@@ -299,10 +581,9 @@ ENUMERABLE_BOUNDED_INTEGRAL(Word64)
299#define ENUMERABLE_UNBOUNDED_INTEGRAL(INTEGRAL_TYPE) \
581#define ENUMERABLE_UNBOUNDED_INTEGRAL(INTEGRAL_TYPE) \
300instance Enumerable INTEGRAL_TYPE where { \
582instance Enumerable INTEGRAL_TYPE where { \
301 {-# INLINE enumerateFrom #-}; \
583 {-# INLINE enumerateFrom #-}; \
302− enumerateFrom = supplySecond 1 enumerateFromStepIntegral; \
584+ enumerateFrom = enumerateFromIntegral; \
303 {-# INLINE enumerateFromThen #-}; \
585 {-# INLINE enumerateFromThen #-}; \
304− enumerateFromThen next = \
586+ enumerateFromThen = enumerateFromThenIntegral; \
305− lmap (\from -> (from, next - from)) enumerateFromStepIntegral; \
306 {-# INLINE enumerateFromTo #-}; \
587 {-# INLINE enumerateFromTo #-}; \
307 enumerateFromTo = enumerateFromToIntegral; \
588 enumerateFromTo = enumerateFromToIntegral; \
308 {-# INLINE enumerateFromThenTo #-}; \
589 {-# INLINE enumerateFromThenTo #-}; \
@@ -329,10 +610,18 @@ ENUMERABLE_FRACTIONAL((Ratio a),Integral a)
330instance Enumerable a => Enumerable (Identity a) where
611instance Enumerable a => Enumerable (Identity a) where
331 {-# INLINE enumerateFrom #-}
612 {-# INLINE enumerateFrom #-}
332− enumerateFrom = map Identity $ lmap runIdentity enumerateFrom
614+ map Identity $ lmap runIdentity enumerateFrom
333 {-# INLINE enumerateFromThen #-}
615 {-# INLINE enumerateFromThen #-}
334− enumerateFromThen = undefined
616+ enumerateFromThen =
617+ map Identity $ lmap (bimap runIdentity runIdentity) enumerateFromThen
335 {-# INLINE enumerateFromTo #-}
618 {-# INLINE enumerateFromTo #-}
336− enumerateFromTo = undefined
619+ enumerateFromTo =
620+ map Identity $ lmap (bimap runIdentity runIdentity) enumerateFromThen
337 {-# INLINE enumerateFromThenTo #-}
621 {-# INLINE enumerateFromThenTo #-}
338− enumerateFromThenTo = undefined
622+ enumerateFromThenTo =
625+ (\(from, next, to) ->
626+ (runIdentity from, runIdentity next, runIdentity to))