Hoogle Search

Within LTS Haskell 24.32 (ghc-9.10.3)

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

Exact lookup

1. getNumCapabilities :: IO Int

   base	GHC.Conc.Sync

   Returns the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. To change this value, use setNumCapabilities.

2. getNumProcessors :: IO Int

   base	GHC.Conc.Sync

   Returns the number of CPUs that the machine has

3. setNumCapabilities :: Int -> IO ()

   base	GHC.Conc.Sync

   Set the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. The number passed to forkOn is interpreted modulo this value. The initial value is given by the +RTS -N runtime flag. This is also the number of threads that will participate in parallel garbage collection. It is strongly recommended that the number of capabilities is not set larger than the number of physical processor cores, and it may often be beneficial to leave one or more cores free to avoid contention with other processes in the machine.

4. module GHC.Enum

   The Enum and Bounded classes.

5. class Enum a

   base	GHC.Enum

   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. boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]

   base	GHC.Enum

   No documentation available.

7. boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]

   base	GHC.Enum

   No documentation available.

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

   base	GHC.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]

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

   base	GHC.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]

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

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

Page 142 of many | Previous | Next