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. enum :: String -> Name -> [Name] -> [(String, Integer)] -> DecsQ

    c-enum Foreign.C.Enum

    Write like the following.

    enum "Foo" ''Int [''Show, ''Read, ''Eq] [
    ("FooError", - 1),
    ("FooZero", 0),
    ("FooOne", 1),
    ("FooTwo", 2) ]
    
    Then you get like the following.
    newtype Foo = Foo Int deriving Eq
    
    pattern FooError :: Int -> Foo
    pattern FooError <- Foo (- 1) where
    FooError = Foo (- 1)
    
    pattern FooZero :: Int -> Foo
    ...
    
    
    instance Show Foo where
    showsPrec = ...
    
    instance Read Foo where
    readPrec = ...
    
    And you can read and show like the following.
    > Foo $ - 1
    FooError
    > FooTwo
    FooTwo
    > Foo 3
    Foo 3
    > read "Foo (- 1)" :: Foo
    FooError
    > read "FooOne" :: Foo
    FooOne
    

  2. enumMems :: String -> [(String, Integer)] -> DecsQ

    c-enum Foreign.C.Enum

    You can define enum members separately.

    enumMems "Foo" [
    ("FooThree", 3),
    ("FooFour", 4) ]
    

  3. class Enum a

    classy-prelude ClassyPrelude

    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
    

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

    classy-prelude ClassyPrelude

    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]

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

    classy-prelude ClassyPrelude

    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]

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

    classy-prelude ClassyPrelude

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

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

    classy-prelude ClassyPrelude

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

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

    classy-prelude ClassyPrelude

    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.

  9. signum :: Num a => a -> a

    classy-prelude ClassyPrelude

    Sign of a number. The functions abs and signum should satisfy the law:

    abs x * signum x == x
    
    For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

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

    classy-prelude ClassyPrelude

    Convert from an Int.

Page 276 of many | Previous | Next