Hoogle Search

Within LTS Haskell 24.67 (ghc-9.10.3)

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

  1. colorNum :: ColorOptions -> Style

    pretty-simple Text.Pretty.Simple

    Color to use for numbers.

  2. colorNum :: ColorOptions -> Style

    pretty-simple Text.Pretty.Simple.Internal.Color

    Color to use for numbers.

  3. parseNumberLit :: Char -> String -> (String, String)

    pretty-simple Text.Pretty.Simple.Internal.ExprParser

    Parses integers and reals, like 123 and 45.67. To be more precise, any numbers matching the regex \d+(\.\d+)? should get parsed by this function.

    >>> parseNumberLit '3' "456hello world []"
    ("3456","hello world []")
    
    >>> parseNumberLit '0' ".12399880 foobar"
    ("0.12399880"," foobar")
    

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

    serialise Codec.Serialise.Class

    Number of constructor of given value

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

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

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

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

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

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

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

Page 221 of many | Previous | Next