Hoogle Search

Within LTS Haskell 24.50 (ghc-9.10.3)

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

Exact lookup

1. conNumber :: forall (a :: k) . GSerialiseSum f => f a -> Word

   serialise	Codec.Serialise.Class

   Number of constructor of given value

2. EventRetryNonNumeric :: ByteString -> EventIgnoreReason

   servant-client-core	Servant.Client.Core.ServerSentEvents

   No documentation available.

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

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

5. class Enum a

   basement	Basement.Compat.Base

   Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold:

   • The calls succ maxBound and pred minBound should result in a runtime error.
   • fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
   • enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
   where
   bound | fromEnum y >= fromEnum x = maxBound
   | otherwise                = minBound
   

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

   basement	Basement.Compat.Base

   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]

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

   basement	Basement.Compat.Base

   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]

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

   basement	Basement.Compat.Base

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

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

   basement	Basement.Compat.Base

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

10. fromEnum :: Enum a => a -> Int

    basement	Basement.Compat.Base

    Convert to an Int. It is implementation-dependent what fromEnum returns when applied to a value that is too large to fit in an Int.

Page 220 of many | Previous | Next