Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

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

   relude	Relude.Enum

   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 = []
   
   

   Examples

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

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

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

   relude	Relude.Enum

   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] = []

3. enumerate :: Enumerable t => [Some t]

   selective	Control.Selective.Multi

   No documentation available.

4. enumFrom :: forall (m :: Type -> Type) n r . (Monad m, Enum n) => n -> Stream (Of n) m r

   streaming	Streaming.Prelude

   An infinite stream of enumerable values, starting from a given value. It is the same as S.iterate succ. Because their return type is polymorphic, enumFrom, enumFromThen and iterate are useful with functions like zip and zipWith, which require the zipped streams to have the same return type. For example, with each [1..] the following bit of connect-and-resume would not compile:

   >>> rest <- S.print $ S.zip (S.enumFrom 1) $ S.splitAt 3 $ S.each ['a'..'z']
   (1,'a')
   (2,'b')
   (3,'c')
   
   >>> S.print $ S.take 3 rest
   'd'
   'e'
   'f'
   

5. enumFromThen :: forall (m :: Type -> Type) a r . (Monad m, Enum a) => a -> a -> Stream (Of a) m r

   streaming	Streaming.Prelude

   An infinite sequence of enumerable values at a fixed distance, determined by the first and second values. See the discussion of enumFrom

   >>> S.print $ S.take 3 $ S.enumFromThen 100 200
   100
   200
   300
   

6. enumFromN :: forall (v :: Type -> Type) (n :: Nat) a . (KnownNat n, Vector v a, Num a) => a -> Vector v n a

   vector-sized	Data.Vector.Generic.Sized

   O(n) Yield a vector of length n containing the values x, x+1, ... x + (n - 1). The length is inferred from the type.

7. enumFromN' :: forall (v :: Type -> Type) (n :: Nat) a p . (KnownNat n, Vector v a, Num a) => a -> p n -> Vector v n a

   vector-sized	Data.Vector.Generic.Sized

   O(n) Yield a vector of length n containing the values x, x+1, ..., x + (n - 1) The length is given explicitly as a Proxy argument.

8. enumFromStepN :: forall (v :: Type -> Type) (n :: Nat) a . (KnownNat n, Vector v a, Num a) => a -> a -> Vector v n a

   vector-sized	Data.Vector.Generic.Sized

   O(n) Yield a vector of the given length containing the values x, x+y, x+2y, ... x + (n - 1)y. The length is inferred from the type.

9. enumFromStepN' :: forall (v :: Type -> Type) (n :: Nat) a p . (KnownNat n, Vector v a, Num a) => a -> a -> p n -> Vector v n a

   vector-sized	Data.Vector.Generic.Sized

   O(n) Yield a vector of the given length containing the values x, x+y, x+2y, ..., x + (n - 1)y. The length is given explicitly as a Proxy argument.

10. enumFromN :: forall (n :: Nat) a . (KnownNat n, Prim a, Num a) => a -> Vector n a

    vector-sized	Data.Vector.Primitive.Sized

    O(n) Yield a vector of length n containing the values x, x+1, ..., x + (n - 1). The length is inferred from the type.

Page 46 of many | Previous | Next