enumFromTo -package:basic-prelude

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

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

Used in Haskell's translation of [n..m] with [n..m] = enumFromTo n m, a possible implementation being

enumFromTo n m
| n <= m = n : enumFromTo (succ n) m
| otherwise = []

Examples

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

enumFromTo :: Enum a => a -> a -> Vector a

vector Data.Vector Data.Vector.Strict

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If possible, use enumFromN instead.

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

vector Data.Vector.Fusion.Bundle

Enumerate values WARNING: This operations can be very inefficient. If at all possible, use enumFromStepN instead.

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

vector Data.Vector.Fusion.Bundle.Monadic

Enumerate values WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

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

vector Data.Vector.Fusion.Stream.Monadic

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

vector Data.Vector.Generic

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If possible, use enumFromN instead.

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

vector Data.Vector.Primitive

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If possible, use enumFromN instead.

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

vector Data.Vector.Storable

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If possible, use enumFromN instead.

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

vector Data.Vector.Unboxed

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If possible, use enumFromN instead.

enumFromTo :: (Monad m, Enum a, Ord a) => a -> a -> ConduitT i a m ()

conduit Data.Conduit.Combinators

Enumerate from a value to a final value, inclusive, via succ. This is generally more efficient than using Prelude's enumFromTo and combining with sourceList since this avoids any intermediate data structures. Subject to fusion

enumFromTo :: (Enum o, Eq o, Monad m) => o -> o -> Pipe l i o u m ()

conduit Data.Conduit.Internal

enumFromTo :: (Enum a, Ord a, Monad m) => a -> a -> ConduitT i a m ()

conduit Data.Conduit.List

Enumerate from a value to a final value, inclusive, via succ. This is generally more efficient than using Prelude's enumFromTo and combining with sourceList since this avoids any intermediate data structures. Subject to fusion Since 0.4.2

enumFromTo :: Enum 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..m] with [n..m] = enumFromTo n m, a possible implementation being enumFromTo n m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For example:

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

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

ghc GHC.Prelude.Basic

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

rio RIO.Vector

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If at all possible, use enumFromN instead.

enumFromTo :: Enum a => a -> a -> Vector a

rio RIO.Vector.Boxed

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If at all possible, use enumFromN instead.

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

rio RIO.Vector.Storable

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If at all possible, use enumFromN instead.

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

rio RIO.Vector.Unboxed

O(n) Enumerate values from x to y. WARNING: This operation can be very inefficient. If at all possible, use enumFromN instead.

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

sbv Data.SBV Data.SBV.List

enumFromTo m n. Symbolic version of [m .. n]

enumFromTo :: (List l, Enum a) => a -> a -> l a

List Data.List.Class

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

nonempty-vector Data.Vector.NonEmpty

O(n) Enumerate values from x to y. 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 enumFromN instead.

enumFromTo :: (Enum a, Ord a) => a -> a -> Acc a

acc Acc

Enumerate in range, inclusively.

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

unboxing-vector Data.Vector.Unboxing

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

vector-stream Data.Stream.Monadic

Enumerate values WARNING: This operation can be very inefficient. If at all possible, use enumFromStepN instead.

enumFromTo :: UpwardEnum a => a -> a -> [a]

prelude-safeenum Prelude.SafeEnum

Return the elements of enumFrom x, filtering out everything that succeeds z. If x succeeds z, then the resulting list is empty; otherwise, it is non-empty, since it includes x. In GHC, the default implementation is a "good producer" for list fusion.