enumFromTo -package:conduit

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 :: 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 :: Enum a => a -> a -> [a]
basic-prelude CorePrelude
Used in Haskell's translation of [n..m].
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.
EnumFromTo :: l -> Exp l -> Exp l -> Exp l
haskell-src-exts Language.Haskell.Exts.Syntax
bounded arithmetic sequence, incrementing by 1 [from .. to]
data EnumFromTo (a :: Nat) (b :: Nat) (c :: [Nat])
harpie Harpie.Shape
Enumerate between two Nats 
>>> :k! Eval (EnumFromTo 0 3)
...
= [0, 1, 2, 3]