Hoogle Search

Within LTS Haskell 24.35 (ghc-9.10.3)

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

Exact lookup

1. enumSequenceFrom :: Num a => a -> Sequence a

   math-functions	Numeric.Series

   enumSequenceFrom x generate sequence: <math>

2. enumSequenceFromStep :: Num a => a -> a -> Sequence a

   math-functions	Numeric.Series

   enumSequenceFromStep x d generate sequence: <math>

3. enumLaws :: (Enum a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws

   quickcheck-classes-base	Test.QuickCheck.Classes.Base

   Tests the following properties:

   • Succ Pred Identity succ (pred x) ≡ x
   • Pred Succ Identity pred (succ x) ≡ x
   This only works for Enum types that are not bounded, meaning that succ and pred must be total. This means that these property tests work correctly for types like Integer but not for Int. Sadly, there is not a good way to test fromEnum and toEnum, since many types that have reasonable implementations for succ and pred have more inhabitants than Int does.

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

   selective	Control.Selective.Multi

   No documentation available.

5. enumFrom :: Enum a => a -> [a]

   relude	Relude.Enum

   Used in Haskell's translation of [n..] with [n..] = enumFrom n, a possible implementation being enumFrom n = n : enumFrom (succ n).

   Examples

   • enumFrom 4 :: [Integer] = [4,5,6,7,...]

   • enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound ::
     Int]

6. enumFromThen :: Enum a => a -> a -> [a]

   relude	Relude.Enum

   Used in Haskell's translation of [n,n'..] with [n,n'..] = enumFromThen n n', a possible implementation being enumFromThen n n' = n : n' : worker (f x) (f x n'), worker s v = v : worker s (s v), x = fromEnum n' - fromEnum n and

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

   Examples

   • enumFromThen 4 6 :: [Integer] = [4,6,8,10...]

   • enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound ::
     Int]

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

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

9. 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'
   

10. 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
    

Page 46 of many | Previous | Next