enumFromThenTo -package:prelude-safeenum

enumFromThenTo :: Enum a => a -> a -> a -> [a]

base Prelude Data.Enum GHC.Enum, ghc-internal GHC.Internal.Enum, verset Verset

f n y
| n > 0 = f (n - 1) (succ y)
| n < 0 = f (n + 1) (pred y)
| otherwise = y

and

worker s c v m
| c v m = v : worker s c (s v) m
| otherwise = []

Examples

enumFromThenTo 4 2 -6 :: [Integer] =
[4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

enumFromThenTo :: Enum a => a -> a -> a -> Vector a

vector Data.Vector Data.Vector.Strict

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If possible, use enumFromStepN instead.

enumFromThenTo :: forall a (v :: Type -> Type) . Enum a => a -> a -> a -> Bundle v a

vector Data.Vector.Fusion.Bundle

Enumerate values with a given step. WARNING: This operations is very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: forall a (m :: Type -> Type) (v :: Type -> Type) . (Enum a, Monad m) => a -> a -> a -> Bundle m v a

vector Data.Vector.Fusion.Bundle.Monadic

Enumerate values with a given step. WARNING: This operation is very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: forall a (m :: Type -> Type) . (Enum a, Monad m) => a -> a -> a -> Stream m a

vector Data.Vector.Fusion.Stream.Monadic

enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a

vector Data.Vector.Generic

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If possible, use enumFromStepN instead.

enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a

vector Data.Vector.Primitive

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If possible, use enumFromStepN instead.

enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a

vector Data.Vector.Storable

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If possible, use enumFromStepN instead.

enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a

vector Data.Vector.Unboxed

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If possible, use enumFromStepN instead.

enumFromThenTo :: Enum a => a -> a -> a -> [a]

hedgehog Hedgehog.Internal.Prelude, base-compat Prelude.Compat, protolude Protolude Protolude.Base, relude Relude.Enum, base-prelude BasePrelude, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base, Cabal-syntax Distribution.Compat.Prelude, ihaskell IHaskellPrelude, basement Basement.Compat.Base Basement.Imports, numhask NumHask.Prelude, clash-prelude Clash.HaskellPrelude, foundation Foundation, ghc-lib-parser GHC.Prelude.Basic, prelude-compat Prelude2010, dimensional Numeric.Units.Dimensional.Prelude, rebase Rebase.Prelude, mixed-types-num Numeric.MixedTypes.PreludeHiding, xmonad-contrib XMonad.Config.Prime, constrained-categories Control.Category.Constrained.Prelude Control.Category.Hask, copilot-language Copilot.Language.Prelude, incipit-base Incipit.Base, LambdaHack Game.LambdaHack.Core.Prelude, cabal-install-solver Distribution.Solver.Compat.Prelude, faktory Faktory.Prelude, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude, hledger-web Hledger.Web.Import

Used in Haskell's translation of [n,n'..m] with [n,n'..m] = enumFromThenTo n n' m, a possible implementation being enumFromThenTo n n' m = worker (f x) (c x) n m, x = fromEnum n' - fromEnum n, c x = bool (>=) ((x 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y and worker s c v m | c v m = v : worker s c (s v) m | otherwise = [] For example:

enumFromThenTo 4 2 -6 :: [Integer] =
[4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

enumFromThenTo :: Enum a => a -> a -> a -> [a]

ghc GHC.Prelude.Basic

enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a

rio RIO.Vector

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: Enum a => a -> a -> a -> Vector a

rio RIO.Vector.Boxed

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a

rio RIO.Vector.Storable

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a

rio RIO.Vector.Unboxed

O(n) Enumerate values from x to y with a specific step z. WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: Enum a => a -> a -> a -> [a]

basic-prelude CorePrelude

Used in Haskell's translation of [n,n'..m].

enumFromThenTo :: EnumSymbolic a => SBV a -> SBV a -> SBV a -> SList a

sbv Data.SBV Data.SBV.List

enumFromThenTo m n. Symbolic version of [m, m' .. n]

enumFromThenTo :: Enum a => a -> a -> a -> Maybe (NonEmptyVector a)

nonempty-vector Data.Vector.NonEmpty

O(n) Enumerate values from x to y with a specific step z. If an enumeration does not use meaningful indices, Nothing is returned, otherwise, Just containing a non-empty vector. WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromThenTo :: (Enum a, Unboxable a) => a -> a -> a -> Vector a

unboxing-vector Data.Vector.Unboxing

enumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Stream m a

vector-stream Data.Stream.Monadic

Enumerate values with a given step. WARNING: This operation is very inefficient. If at all possible, use enumFromStepN instead.

EnumFromThenTo :: l -> Exp l -> Exp l -> Exp l -> Exp l

haskell-src-exts Language.Haskell.Exts.Syntax

bounded arithmetic sequence, with first two elements given [from, then .. to]

pattern EnumFromThenTo :: Exp -> Exp -> Exp -> Exp

haskell-src-exts-simple Language.Haskell.Exts.Simple.Syntax

enumFromThenToClassOpKey :: Unique

ghc GHC.Builtin.Names

enumFromThenToName :: Name

ghc GHC.Builtin.Names

enumFromThenTo_RDR :: RdrName

ghc GHC.Builtin.Names