Hoogle Search

Within LTS Haskell 24.51 (ghc-9.10.3)

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

Exact lookup

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

   basic-prelude	CorePrelude

   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]

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

   basic-prelude	CorePrelude

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

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

   basic-prelude	CorePrelude

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

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

   basic-prelude	CorePrelude

   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.

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

   basic-prelude	CorePrelude

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

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

   basic-prelude	CorePrelude

   Convert from an Int.

7. package c-enum

   To make a type corresponding to an enum of C language Please see the README on GitHub at https://github.com/YoshikuniJujo/c-enum#readme

8. module Foreign.C.Enum

   No documentation available.

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

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

    c-enum	Foreign.C.Enum

    You can define enum members separately.

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

Page 274 of many | Previous | Next