{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE Trustworthy #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Internal.Enum
-- Copyright   :  (c) The University of Glasgow, 1992-2002
-- License     :  see libraries/base/LICENSE
--
-- Maintainer  :  ghc-devs@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (GHC extensions)
--
-- The 'Enum' and 'Bounded' classes.
--
-----------------------------------------------------------------------------

#include "MachDeps.h"

module GHC.Internal.Enum
  ( Bounded(..)
  , Enum(..)
  , boundedEnumFrom
  , boundedEnumFromThen
  , toEnumError
  , fromEnumError
  , succError
  , predError
  , enumIntToWord

  -- Instances for Bounded and Enum: (), Char, Int
  )
where

import GHC.Internal.Base hiding ( many )
import GHC.Internal.Char
import GHC.Num.Integer
import GHC.Internal.Num
import GHC.Internal.Show
import GHC.Tuple (Solo (..))
default ()              -- Double isn't available yet

-- | The 'Bounded' class is used to name the upper and lower limits of a
-- type.  'Ord' is not a superclass of 'Bounded' since types that are not
-- totally ordered may also have upper and lower bounds.
--
-- The 'Bounded' class may be derived for any enumeration type;
-- 'minBound' is the first constructor listed in the @data@ declaration
-- and 'maxBound' is the last.
-- 'Bounded' may also be derived for single-constructor datatypes whose
-- constituent types are in 'Bounded'.

class  Bounded a  where
    minBound, maxBound :: a

-- | 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
--
class  Enum a   where
    -- | Successor of a value. For numeric types, 'succ' adds 1.
    succ                :: a -> a
    -- | Predecessor of a value. For numeric types, 'pred' subtracts 1.
    pred                :: a -> a
    -- | Convert from an 'Int'.
    toEnum              :: Int -> a
    -- | 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'.
    fromEnum            :: a -> Int
    -- | 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]@
    enumFrom            :: a -> [a]
    -- | 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]@
    enumFromThen        :: a -> a -> [a]
    -- | 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] = []@
    enumFromTo          :: a -> a -> [a]
    -- | 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] = []@
    enumFromThenTo      :: a -> a -> a -> [a]

    succ = Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> (a -> Int) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int -> Int) -> (a -> Int) -> a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum

    pred = Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> (a -> Int) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1) (Int -> Int) -> (a -> Int) -> a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum

    -- See Note [Stable Unfolding for list producers]
    {-# INLINABLE enumFrom #-}
    enumFrom a
x = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [a -> Int
forall a. Enum a => a -> Int
fromEnum a
x ..]

    -- See Note [Stable Unfolding for list producers]
    {-# INLINABLE enumFromThen #-}
    enumFromThen a
x a
y = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [a -> Int
forall a. Enum a => a -> Int
fromEnum a
x, a -> Int
forall a. Enum a => a -> Int
fromEnum a
y ..]

    -- See Note [Stable Unfolding for list producers]
    {-# INLINABLE enumFromTo #-}
    enumFromTo a
x a
y = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [a -> Int
forall a. Enum a => a -> Int
fromEnum a
x .. a -> Int
forall a. Enum a => a -> Int
fromEnum a
y]

    -- See Note [Stable Unfolding for list producers]
    {-# INLINABLE enumFromThenTo #-}
    enumFromThenTo a
x1 a
x2 a
y = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [a -> Int
forall a. Enum a => a -> Int
fromEnum a
x1, a -> Int
forall a. Enum a => a -> Int
fromEnum a
x2 .. a -> Int
forall a. Enum a => a -> Int
fromEnum a
y]

-- See Note [Inline Enum method helpers]
{-# INLINE boundedEnumFrom #-}
-- Default methods for bounded enumerations
boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
boundedEnumFrom :: forall a. (Enum a, Bounded a) => a -> [a]
boundedEnumFrom a
n = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [a -> Int
forall a. Enum a => a -> Int
fromEnum a
n .. a -> Int
forall a. Enum a => a -> Int
fromEnum (a
forall a. Bounded a => a
maxBound a -> a -> a
forall a. a -> a -> a
`asTypeOf` a
n)]

-- See Note [Inline Enum method helpers]
{-# INLINE boundedEnumFromThen #-}
boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen :: forall a. (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen a
n1 a
n2
  | Int
i_n2 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
i_n1  = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [Int
i_n1, Int
i_n2 .. a -> Int
forall a. Enum a => a -> Int
fromEnum (a
forall a. Bounded a => a
maxBound a -> a -> a
forall a. a -> a -> a
`asTypeOf` a
n1)]
  | Bool
otherwise     = (Int -> a) -> [Int] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Int -> a
forall a. Enum a => Int -> a
toEnum [Int
i_n1, Int
i_n2 .. a -> Int
forall a. Enum a => a -> Int
fromEnum (a
forall a. Bounded a => a
minBound a -> a -> a
forall a. a -> a -> a
`asTypeOf` a
n1)]
  where
    i_n1 :: Int
i_n1 = a -> Int
forall a. Enum a => a -> Int
fromEnum a
n1
    i_n2 :: Int
i_n2 = a -> Int
forall a. Enum a => a -> Int
fromEnum a
n2

{- Note [Stable Unfolding for list producers]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The INLINABLE/INLINE pragmas ensure that we export stable (unoptimised)
unfoldings in the interface file so we can do list fusion at usage sites.

Related tickets: #15185, #8763, #18178.

Note [Inline Enum method helpers]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The overloaded `numericEnumFrom` functions are used to abbreviate Enum
instances. We call them "method helpers".  For example, in GHC.Internal.Float:

  numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
  mnumericEnumFromTo = ...blah...

  instance  Enum Double  where
     ...
    enumFromTo = numericEnumFromTo

Similarly with the overloaded `boundedEnumFrom` functions. E.g. in GHC.Internal.Word

  boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
  boundedEnumFrom n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)]

  instance Enum Word8 where
    ...
    enumFrom            = boundedEnumFrom

In both cases, it is super-important to specialise these overloaded
helper function (`numericEnumFromTo`, `boundedEnumFrom` etc) to the
particular type of the instance, else every use of that instance will
be inefficient.

Moreover (see Note [Stable Unfolding for list producers]) the helper
function is a list producer, so we want it to have a stable unfolding
to support fusion.

So we attach an INLINE pragma to them.

Alternatives might be
* An `INLINABLE` pragma on `numericEnumFromTo`, relying on the
  specialiser to create a specialised version.  But (a) if the
  instance method is marked INLINE we may get spurious INLINE
  loop-breaker warnings (#21343), and (b) specialision gains no extra
  sharing, because there is just one call at each type.

* Using `inline` at the call site
    enumFromTo = inline numericEnumFromTo
  But that means remembering to do this in multiple places.
-}

------------------------------------------------------------------------
-- Helper functions
------------------------------------------------------------------------

{-# NOINLINE toEnumError #-}
toEnumError :: (Show a) => String -> Int -> (a,a) -> b
toEnumError :: forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
inst_ty Int
i (a
mi,a
ma) =
    String -> b
forall a. String -> a
errorWithoutStackTrace (String -> b) -> String -> b
forall a b. (a -> b) -> a -> b
$ String
"Enum.toEnum{" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
inst_ty String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"}: tag (" String -> String -> String
forall a. [a] -> [a] -> [a]
++
            Int -> String
forall a. Show a => a -> String
show Int
i String -> String -> String
forall a. [a] -> [a] -> [a]
++
            String
") is outside of enumeration's range (" String -> String -> String
forall a. [a] -> [a] -> [a]
++
            a -> String
forall a. Show a => a -> String
show a
mi String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"," String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
ma String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"

{-# NOINLINE fromEnumError #-}
fromEnumError :: (Show a) => String -> a -> b
fromEnumError :: forall a b. Show a => String -> a -> b
fromEnumError String
inst_ty a
x =
    String -> b
forall a. String -> a
errorWithoutStackTrace (String -> b) -> String -> b
forall a b. (a -> b) -> a -> b
$ String
"Enum.fromEnum{" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
inst_ty String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"}: value (" String -> String -> String
forall a. [a] -> [a] -> [a]
++
            a -> String
forall a. Show a => a -> String
show a
x String -> String -> String
forall a. [a] -> [a] -> [a]
++
            String
") is outside of Int's bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++
            (Int, Int) -> String
forall a. Show a => a -> String
show (Int
forall a. Bounded a => a
minBound::Int, Int
forall a. Bounded a => a
maxBound::Int)

{-# NOINLINE succError #-}
succError :: String -> a
succError :: forall a. String -> a
succError String
inst_ty =
    String -> a
forall a. String -> a
errorWithoutStackTrace (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"Enum.succ{" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
inst_ty String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"}: tried to take `succ' of last tag in enumeration"

{-# NOINLINE predError #-}
predError :: String -> a
predError :: forall a. String -> a
predError String
inst_ty =
    String -> a
forall a. String -> a
errorWithoutStackTrace (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"Enum.pred{" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
inst_ty String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"}: tried to take `pred' of first tag in enumeration"

------------------------------------------------------------------------
-- Tuples
------------------------------------------------------------------------

-- | @since base-2.01
deriving instance Bounded ()

-- | @since base-2.01
instance Enum () where
    succ :: () -> ()
succ ()
_      = String -> ()
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.().succ: bad argument"
    pred :: () -> ()
pred ()
_      = String -> ()
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.().pred: bad argument"

    toEnum :: Int -> ()
toEnum Int
x | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0    = ()
             | Bool
otherwise = String -> ()
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.().toEnum: bad argument"

    fromEnum :: () -> Int
fromEnum () = Int
0
    enumFrom :: () -> [()]
enumFrom ()         = [()]
    enumFromThen :: () -> () -> [()]
enumFromThen () ()  = let many :: [()]
many = ()() -> [()] -> [()]
forall a. a -> [a] -> [a]
:[()]
many in [()]
many
    enumFromTo :: () -> () -> [()]
enumFromTo () ()    = [()]
    enumFromThenTo :: () -> () -> () -> [()]
enumFromThenTo () () () = let many :: [()]
many = ()() -> [()] -> [()]
forall a. a -> [a] -> [a]
:[()]
many in [()]
many

instance Enum a => Enum (Solo a) where
    succ :: Solo a -> Solo a
succ (MkSolo a
a) = a -> Solo a
forall a. a -> Solo a
MkSolo (a -> a
forall a. Enum a => a -> a
succ a
a)
    pred :: Solo a -> Solo a
pred (MkSolo a
a) = a -> Solo a
forall a. a -> Solo a
MkSolo (a -> a
forall a. Enum a => a -> a
pred a
a)

    toEnum :: Int -> Solo a
toEnum Int
x = a -> Solo a
forall a. a -> Solo a
MkSolo (Int -> a
forall a. Enum a => Int -> a
toEnum Int
x)

    fromEnum :: Solo a -> Int
fromEnum (MkSolo a
x) = a -> Int
forall a. Enum a => a -> Int
fromEnum a
x
    enumFrom :: Solo a -> [Solo a]
enumFrom (MkSolo a
x) = [a -> Solo a
forall a. a -> Solo a
MkSolo a
a | a
a <- a -> [a]
forall a. Enum a => a -> [a]
enumFrom a
x]
    enumFromThen :: Solo a -> Solo a -> [Solo a]
enumFromThen (MkSolo a
x) (MkSolo a
y) =
      [a -> Solo a
forall a. a -> Solo a
MkSolo a
a | a
a <- a -> a -> [a]
forall a. Enum a => a -> a -> [a]
enumFromThen a
x a
y]
    enumFromTo :: Solo a -> Solo a -> [Solo a]
enumFromTo (MkSolo a
x) (MkSolo a
y) =
      [a -> Solo a
forall a. a -> Solo a
MkSolo a
a | a
a <- a -> a -> [a]
forall a. Enum a => a -> a -> [a]
enumFromTo a
x a
y]
    enumFromThenTo :: Solo a -> Solo a -> Solo a -> [Solo a]
enumFromThenTo (MkSolo a
x) (MkSolo a
y) (MkSolo a
z) =
      [a -> Solo a
forall a. a -> Solo a
MkSolo a
a | a
a <- a -> a -> a -> [a]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo a
x a
y a
z]

deriving instance Bounded a => Bounded (Solo a)
-- Report requires instances up to 15
-- | @since base-2.01
deriving instance (Bounded a, Bounded b)
        => Bounded (a,b)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c)
        => Bounded (a,b,c)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d)
        => Bounded (a,b,c,d)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e)
        => Bounded (a,b,c,d,e)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f)
        => Bounded (a,b,c,d,e,f)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g)
        => Bounded (a,b,c,d,e,f,g)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h)
        => Bounded (a,b,c,d,e,f,g,h)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i)
        => Bounded (a,b,c,d,e,f,g,h,i)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j)
        => Bounded (a,b,c,d,e,f,g,h,i,j)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k)
        => Bounded (a,b,c,d,e,f,g,h,i,j,k)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l)
        => Bounded (a,b,c,d,e,f,g,h,i,j,k,l)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m)
        => Bounded (a,b,c,d,e,f,g,h,i,j,k,l,m)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m, Bounded n)
        => Bounded (a,b,c,d,e,f,g,h,i,j,k,l,m,n)
-- | @since base-2.01
deriving instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m, Bounded n, Bounded o)
        => Bounded (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)

------------------------------------------------------------------------
-- Bool
------------------------------------------------------------------------

-- | @since base-2.01
deriving instance Bounded Bool

-- | @since base-2.01
instance Enum Bool where
  succ :: Bool -> Bool
succ Bool
False = Bool
True
  succ Bool
True  = String -> Bool
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.Bool.succ: bad argument"

  pred :: Bool -> Bool
pred Bool
True  = Bool
False
  pred Bool
False  = String -> Bool
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.Bool.pred: bad argument"

  toEnum :: Int -> Bool
toEnum Int
n | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0    = Bool
False
           | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1    = Bool
True
           | Bool
otherwise = String -> Bool
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.Bool.toEnum: bad argument"

  fromEnum :: Bool -> Int
fromEnum Bool
False = Int
0
  fromEnum Bool
True  = Int
1

  -- Use defaults for the rest
  enumFrom :: Bool -> [Bool]
enumFrom     = Bool -> [Bool]
forall a. (Enum a, Bounded a) => a -> [a]
boundedEnumFrom
  enumFromThen :: Bool -> Bool -> [Bool]
enumFromThen = Bool -> Bool -> [Bool]
forall a. (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen

------------------------------------------------------------------------
-- Ordering
------------------------------------------------------------------------

-- | @since base-2.01
deriving instance Bounded Ordering
-- | @since base-2.01
instance Enum Ordering where
  succ :: Ordering -> Ordering
succ Ordering
LT = Ordering
EQ
  succ Ordering
EQ = Ordering
GT
  succ Ordering
GT = String -> Ordering
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.Ordering.succ: bad argument"

  pred :: Ordering -> Ordering
pred Ordering
GT = Ordering
EQ
  pred Ordering
EQ = Ordering
LT
  pred Ordering
LT = String -> Ordering
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.Ordering.pred: bad argument"

  toEnum :: Int -> Ordering
toEnum Int
n | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Ordering
LT
           | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = Ordering
EQ
           | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2 = Ordering
GT
  toEnum Int
_ = String -> Ordering
forall a. String -> a
errorWithoutStackTrace String
"Prelude.Enum.Ordering.toEnum: bad argument"

  fromEnum :: Ordering -> Int
fromEnum Ordering
LT = Int
0
  fromEnum Ordering
EQ = Int
1
  fromEnum Ordering
GT = Int
2

  -- Use defaults for the rest
  enumFrom :: Ordering -> [Ordering]
enumFrom     = Ordering -> [Ordering]
forall a. (Enum a, Bounded a) => a -> [a]
boundedEnumFrom
  enumFromThen :: Ordering -> Ordering -> [Ordering]
enumFromThen = Ordering -> Ordering -> [Ordering]
forall a. (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen

------------------------------------------------------------------------
-- Char
------------------------------------------------------------------------

-- | @since base-2.01
instance  Bounded Char  where
    minBound :: Char
minBound =  Char
'\0'
    maxBound :: Char
maxBound =  Char
'\x10FFFF'

-- | @since base-2.01
instance  Enum Char  where
    succ :: Char -> Char
succ (C# Char#
c#)
       | Int# -> Bool
isTrue# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
/=# Int#
0x10FFFF#) = Char# -> Char
C# (Int# -> Char#
chr# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
+# Int#
1#))
       | Bool
otherwise             = String -> Char
forall a. String -> a
errorWithoutStackTrace (String
"Prelude.Enum.Char.succ: bad argument")
    pred :: Char -> Char
pred (C# Char#
c#)
       | Int# -> Bool
isTrue# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
/=# Int#
0#) = Char# -> Char
C# (Int# -> Char#
chr# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
-# Int#
1#))
       | Bool
otherwise                = String -> Char
forall a. String -> a
errorWithoutStackTrace (String
"Prelude.Enum.Char.pred: bad argument")

    toEnum :: Int -> Char
toEnum   = Int -> Char
chr
    fromEnum :: Char -> Int
fromEnum = Char -> Int
ord

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFrom #-}
    enumFrom :: Char -> String
enumFrom (C# Char#
x) = Int# -> Int# -> String
eftChar (Char# -> Int#
ord# Char#
x) Int#
0x10FFFF#
        -- Blarg: technically I guess enumFrom isn't strict!

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromTo #-}
    enumFromTo :: Char -> Char -> String
enumFromTo (C# Char#
x) (C# Char#
y) = Int# -> Int# -> String
eftChar (Char# -> Int#
ord# Char#
x) (Char# -> Int#
ord# Char#
y)

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThen #-}
    enumFromThen :: Char -> Char -> String
enumFromThen (C# Char#
x1) (C# Char#
x2) = Int# -> Int# -> String
efdChar (Char# -> Int#
ord# Char#
x1) (Char# -> Int#
ord# Char#
x2)

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: Char -> Char -> Char -> String
enumFromThenTo (C# Char#
x1) (C# Char#
x2) (C# Char#
y) = Int# -> Int# -> Int# -> String
efdtChar (Char# -> Int#
ord# Char#
x1) (Char# -> Int#
ord# Char#
x2) (Char# -> Int#
ord# Char#
y)

-- See Note [How the Enum rules work]
{-# RULES
"eftChar"       [~1] forall x y.        eftChar x y       = build (\c n -> eftCharFB c n x y)
"efdChar"       [~1] forall x1 x2.      efdChar x1 x2     = build (\ c n -> efdCharFB c n x1 x2)
"efdtChar"      [~1] forall x1 x2 l.    efdtChar x1 x2 l  = build (\ c n -> efdtCharFB c n x1 x2 l)
"eftCharList"   [1]  eftCharFB  (:) [] = eftChar
"efdCharList"   [1]  efdCharFB  (:) [] = efdChar
"efdtCharList"  [1]  efdtCharFB (:) [] = efdtChar
 #-}


-- We can do better than for Ints because we don't
-- have hassles about arithmetic overflow at maxBound
{-# INLINE [0] eftCharFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
eftCharFB :: (Char -> a -> a) -> a -> Int# -> Int# -> a
eftCharFB :: forall a. (Char -> a -> a) -> a -> Int# -> Int# -> a
eftCharFB Char -> a -> a
c a
n Int#
x0 Int#
y = Int# -> a
go Int#
x0
                 where
                    go :: Int# -> a
go Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
># Int#
y) = a
n
                         | Bool
otherwise        = Char# -> Char
C# (Int# -> Char#
chr# Int#
x) Char -> a -> a
`c` Int# -> a
go (Int#
x Int# -> Int# -> Int#
+# Int#
1#)

{-# NOINLINE [1] eftChar #-} -- Inline after rule "eftChar" is inactive
eftChar :: Int# -> Int# -> String
eftChar :: Int# -> Int# -> String
eftChar Int#
x Int#
y | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
># Int#
y ) = []
            | Bool
otherwise         = Char# -> Char
C# (Int# -> Char#
chr# Int#
x) Char -> String -> String
forall a. a -> [a] -> [a]
: Int# -> Int# -> String
eftChar (Int#
x Int# -> Int# -> Int#
+# Int#
1#) Int#
y


-- For enumFromThenTo we give up on inlining
{-# INLINE [0] efdCharFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdCharFB :: (Char -> a -> a) -> a -> Int# -> Int# -> a
efdCharFB :: forall a. (Char -> a -> a) -> a -> Int# -> Int# -> a
efdCharFB Char -> a -> a
c a
n Int#
x1 Int#
x2
  | Int# -> Bool
isTrue# (Int#
delta Int# -> Int# -> Int#
>=# Int#
0#) = (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_up_char_fb Char -> a -> a
c a
n Int#
x1 Int#
delta Int#
0x10FFFF#
  | Bool
otherwise              = (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_dn_char_fb Char -> a -> a
c a
n Int#
x1 Int#
delta Int#
0#
  where
    !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1

{-# NOINLINE [1] efdChar #-} -- Inline after rule "efdChar" is inactive
efdChar :: Int# -> Int# -> String
efdChar :: Int# -> Int# -> String
efdChar Int#
x1 Int#
x2
  | Int# -> Bool
isTrue# (Int#
delta Int# -> Int# -> Int#
>=# Int#
0#) = Int# -> Int# -> Int# -> String
go_up_char_list Int#
x1 Int#
delta Int#
0x10FFFF#
  | Bool
otherwise              = Int# -> Int# -> Int# -> String
go_dn_char_list Int#
x1 Int#
delta Int#
0#
  where
    !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1

{-# INLINE [0] efdtCharFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtCharFB :: (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
efdtCharFB :: forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
efdtCharFB Char -> a -> a
c a
n Int#
x1 Int#
x2 Int#
lim
  | Int# -> Bool
isTrue# (Int#
delta Int# -> Int# -> Int#
>=# Int#
0#) = (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_up_char_fb Char -> a -> a
c a
n Int#
x1 Int#
delta Int#
lim
  | Bool
otherwise              = (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_dn_char_fb Char -> a -> a
c a
n Int#
x1 Int#
delta Int#
lim
  where
    !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1

{-# NOINLINE [1] efdtChar #-} -- Inline after rule "efdtChar" is inactive
efdtChar :: Int# -> Int# -> Int# -> String
efdtChar :: Int# -> Int# -> Int# -> String
efdtChar Int#
x1 Int#
x2 Int#
lim
  | Int# -> Bool
isTrue# (Int#
delta Int# -> Int# -> Int#
>=# Int#
0#) = Int# -> Int# -> Int# -> String
go_up_char_list Int#
x1 Int#
delta Int#
lim
  | Bool
otherwise              = Int# -> Int# -> Int# -> String
go_dn_char_list Int#
x1 Int#
delta Int#
lim
  where
    !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1

go_up_char_fb :: (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_up_char_fb :: forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_up_char_fb Char -> a -> a
c a
n Int#
x0 Int#
delta Int#
lim
  = Int# -> a
go_up Int#
x0
  where
    go_up :: Int# -> a
go_up Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
># Int#
lim) = a
n
            | Bool
otherwise          = Char# -> Char
C# (Int# -> Char#
chr# Int#
x) Char -> a -> a
`c` Int# -> a
go_up (Int#
x Int# -> Int# -> Int#
+# Int#
delta)

go_dn_char_fb :: (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_dn_char_fb :: forall a. (Char -> a -> a) -> a -> Int# -> Int# -> Int# -> a
go_dn_char_fb Char -> a -> a
c a
n Int#
x0 Int#
delta Int#
lim
  = Int# -> a
go_dn Int#
x0
  where
    go_dn :: Int# -> a
go_dn Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
<# Int#
lim) = a
n
            | Bool
otherwise          = Char# -> Char
C# (Int# -> Char#
chr# Int#
x) Char -> a -> a
`c` Int# -> a
go_dn (Int#
x Int# -> Int# -> Int#
+# Int#
delta)

go_up_char_list :: Int# -> Int# -> Int# -> String
go_up_char_list :: Int# -> Int# -> Int# -> String
go_up_char_list Int#
x0 Int#
delta Int#
lim
  = Int# -> String
go_up Int#
x0
  where
    go_up :: Int# -> String
go_up Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
># Int#
lim) = []
            | Bool
otherwise          = Char# -> Char
C# (Int# -> Char#
chr# Int#
x) Char -> String -> String
forall a. a -> [a] -> [a]
: Int# -> String
go_up (Int#
x Int# -> Int# -> Int#
+# Int#
delta)

go_dn_char_list :: Int# -> Int# -> Int# -> String
go_dn_char_list :: Int# -> Int# -> Int# -> String
go_dn_char_list Int#
x0 Int#
delta Int#
lim
  = Int# -> String
go_dn Int#
x0
  where
    go_dn :: Int# -> String
go_dn Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
<# Int#
lim) = []
            | Bool
otherwise          = Char# -> Char
C# (Int# -> Char#
chr# Int#
x) Char -> String -> String
forall a. a -> [a] -> [a]
: Int# -> String
go_dn (Int#
x Int# -> Int# -> Int#
+# Int#
delta)


------------------------------------------------------------------------
-- Int
------------------------------------------------------------------------

{-
Be careful about these instances.
        (a) remember that you have to count down as well as up e.g. [13,12..0]
        (b) be careful of Int overflow
        (c) remember that Int is bounded, so [1..] terminates at maxInt
-}

-- | @since base-2.01
instance  Bounded Int where
    minBound :: Int
minBound =  Int
minInt
    maxBound :: Int
maxBound =  Int
maxInt

-- | @since base-2.01
instance  Enum Int  where
    succ :: Int -> Int
succ Int
x
       | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
forall a. Bounded a => a
maxBound  = String -> Int
forall a. String -> a
succError String
"Int"
       | Bool
otherwise      = Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
    pred :: Int -> Int
pred Int
x
       | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
forall a. Bounded a => a
minBound  = String -> Int
forall a. String -> a
predError String
"Int"
       | Bool
otherwise      = Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1

    toEnum :: Int -> Int
toEnum   Int
x = Int
x
    fromEnum :: Int -> Int
fromEnum Int
x = Int
x

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFrom #-}
    enumFrom :: Int -> [Int]
enumFrom (I# Int#
x) = Int# -> Int# -> [Int]
eftInt Int#
x Int#
maxInt#
        where !(I# Int#
maxInt#) = Int
maxInt
        -- Blarg: technically I guess enumFrom isn't strict!

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromTo #-}
    enumFromTo :: Int -> Int -> [Int]
enumFromTo (I# Int#
x) (I# Int#
y) = Int# -> Int# -> [Int]
eftInt Int#
x Int#
y

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThen #-}
    enumFromThen :: Int -> Int -> [Int]
enumFromThen (I# Int#
x1) (I# Int#
x2) = Int# -> Int# -> [Int]
efdInt Int#
x1 Int#
x2

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: Int -> Int -> Int -> [Int]
enumFromThenTo (I# Int#
x1) (I# Int#
x2) (I# Int#
y) = Int# -> Int# -> Int# -> [Int]
efdtInt Int#
x1 Int#
x2 Int#
y


-----------------------------------------------------
-- eftInt and eftIntFB deal with [a..b], which is the
-- most common form, so we take a lot of care
-- In particular, we have rules for deforestation

{-# RULES
"eftInt"        [~1] forall x y. eftInt x y = build (\ c n -> eftIntFB c n x y)
"eftIntList"    [1] eftIntFB  (:) [] = eftInt
 #-}

{- Note [How the Enum rules work]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Phase 2: eftInt ---> build . eftIntFB
* Phase 1: inline build; eftIntFB (:) --> eftInt
* Phase 0: optionally inline eftInt
-}

{-# NOINLINE [1] eftInt #-}
eftInt :: Int# -> Int# -> [Int]
-- [x1..x2]
eftInt :: Int# -> Int# -> [Int]
eftInt Int#
x0 Int#
y | Int# -> Bool
isTrue# (Int#
x0 Int# -> Int# -> Int#
># Int#
y) = []
            | Bool
otherwise         = Int# -> [Int]
go Int#
x0
               where
                 go :: Int# -> [Int]
go Int#
x = Int# -> Int
I# Int#
x Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: if Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
==# Int#
y)
                               then []
                               else Int# -> [Int]
go (Int#
x Int# -> Int# -> Int#
+# Int#
1#)

{-# INLINE [0] eftIntFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
eftIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> r
eftIntFB :: forall r. (Int -> r -> r) -> r -> Int# -> Int# -> r
eftIntFB Int -> r -> r
c r
n Int#
x0 Int#
y | Int# -> Bool
isTrue# (Int#
x0 Int# -> Int# -> Int#
># Int#
y) = r
n
                  | Bool
otherwise         = Int# -> r
go Int#
x0
                 where
                   go :: Int# -> r
go Int#
x = Int# -> Int
I# Int#
x Int -> r -> r
`c` if Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
==# Int#
y)
                                   then r
n
                                   else Int# -> r
go (Int#
x Int# -> Int# -> Int#
+# Int#
1#)
                        -- Watch out for y=maxBound; hence ==, not >
        -- Be very careful not to have more than one "c"
        -- so that when eftInfFB is inlined we can inline
        -- whatever is bound to "c"


-----------------------------------------------------
-- efdInt and efdtInt deal with [a,b..] and [a,b..c].
-- The code is more complicated because of worries about Int overflow.

-- See Note [How the Enum rules work]
{-# RULES
"efdtInt"       [~1] forall x1 x2 y.
                     efdtInt x1 x2 y = build (\ c n -> efdtIntFB c n x1 x2 y)
"efdtIntUpList" [1]  efdtIntFB (:) [] = efdtInt
 #-}

efdInt :: Int# -> Int# -> [Int]
-- [x1,x2..maxInt]
efdInt :: Int# -> Int# -> [Int]
efdInt Int#
x1 Int#
x2
 | Int# -> Bool
isTrue# (Int#
x2 Int# -> Int# -> Int#
>=# Int#
x1) = case Int
maxInt of I# Int#
y -> Int# -> Int# -> Int# -> [Int]
efdtIntUp Int#
x1 Int#
x2 Int#
y
 | Bool
otherwise           = case Int
minInt of I# Int#
y -> Int# -> Int# -> Int# -> [Int]
efdtIntDn Int#
x1 Int#
x2 Int#
y

{-# NOINLINE [1] efdtInt #-}
efdtInt :: Int# -> Int# -> Int# -> [Int]
-- [x1,x2..y]
efdtInt :: Int# -> Int# -> Int# -> [Int]
efdtInt Int#
x1 Int#
x2 Int#
y
 | Int# -> Bool
isTrue# (Int#
x2 Int# -> Int# -> Int#
>=# Int#
x1) = Int# -> Int# -> Int# -> [Int]
efdtIntUp Int#
x1 Int#
x2 Int#
y
 | Bool
otherwise           = Int# -> Int# -> Int# -> [Int]
efdtIntDn Int#
x1 Int#
x2 Int#
y

{-# INLINE [0] efdtIntFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntFB :: forall r. (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntFB Int -> r -> r
c r
n Int#
x1 Int#
x2 Int#
y
 | Int# -> Bool
isTrue# (Int#
x2 Int# -> Int# -> Int#
>=# Int#
x1) = (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
forall r. (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntUpFB Int -> r -> r
c r
n Int#
x1 Int#
x2 Int#
y
 | Bool
otherwise           = (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
forall r. (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntDnFB Int -> r -> r
c r
n Int#
x1 Int#
x2 Int#
y

-- Requires x2 >= x1
efdtIntUp :: Int# -> Int# -> Int# -> [Int]
efdtIntUp :: Int# -> Int# -> Int# -> [Int]
efdtIntUp Int#
x1 Int#
x2 Int#
y    -- Be careful about overflow!
 | Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
<# Int#
x2) = if Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
<# Int#
x1) then [] else [Int# -> Int
I# Int#
x1]
 | Bool
otherwise = -- Common case: x1 <= x2 <= y
               let !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1 -- >= 0
                   !y' :: Int#
y' = Int#
y Int# -> Int# -> Int#
-# Int#
delta  -- x1 <= y' <= y; hence y' is representable

                   -- Invariant: x <= y
                   -- Note that: z <= y' => z + delta won't overflow
                   -- so we are guaranteed not to overflow if/when we recurse
                   go_up :: Int# -> [Int]
go_up Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
># Int#
y') = [Int# -> Int
I# Int#
x]
                           | Bool
otherwise         = Int# -> Int
I# Int#
x Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Int# -> [Int]
go_up (Int#
x Int# -> Int# -> Int#
+# Int#
delta)
               in Int# -> Int
I# Int#
x1 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Int# -> [Int]
go_up Int#
x2

-- Requires x2 >= x1
{-# INLINE [0] efdtIntUpFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtIntUpFB :: (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntUpFB :: forall r. (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntUpFB Int -> r -> r
c r
n Int#
x1 Int#
x2 Int#
y    -- Be careful about overflow!
 | Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
<# Int#
x2) = if Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
<# Int#
x1) then r
n else Int# -> Int
I# Int#
x1 Int -> r -> r
`c` r
n
 | Bool
otherwise = -- Common case: x1 <= x2 <= y
               let !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1 -- >= 0
                   !y' :: Int#
y' = Int#
y Int# -> Int# -> Int#
-# Int#
delta  -- x1 <= y' <= y; hence y' is representable

                   -- Invariant: x <= y
                   -- Note that: z <= y' => z + delta won't overflow
                   -- so we are guaranteed not to overflow if/when we recurse
                   go_up :: Int# -> r
go_up Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
># Int#
y') = Int# -> Int
I# Int#
x Int -> r -> r
`c` r
n
                           | Bool
otherwise         = Int# -> Int
I# Int#
x Int -> r -> r
`c` Int# -> r
go_up (Int#
x Int# -> Int# -> Int#
+# Int#
delta)
               in Int# -> Int
I# Int#
x1 Int -> r -> r
`c` Int# -> r
go_up Int#
x2

-- Requires x2 <= x1
efdtIntDn :: Int# -> Int# -> Int# -> [Int]
efdtIntDn :: Int# -> Int# -> Int# -> [Int]
efdtIntDn Int#
x1 Int#
x2 Int#
y    -- Be careful about underflow!
 | Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
># Int#
x2) = if Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
># Int#
x1) then [] else [Int# -> Int
I# Int#
x1]
 | Bool
otherwise = -- Common case: x1 >= x2 >= y
               let !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1 -- <= 0
                   !y' :: Int#
y' = Int#
y Int# -> Int# -> Int#
-# Int#
delta  -- y <= y' <= x1; hence y' is representable

                   -- Invariant: x >= y
                   -- Note that: z >= y' => z + delta won't underflow
                   -- so we are guaranteed not to underflow if/when we recurse
                   go_dn :: Int# -> [Int]
go_dn Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
<# Int#
y') = [Int# -> Int
I# Int#
x]
                           | Bool
otherwise         = Int# -> Int
I# Int#
x Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Int# -> [Int]
go_dn (Int#
x Int# -> Int# -> Int#
+# Int#
delta)
   in Int# -> Int
I# Int#
x1 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Int# -> [Int]
go_dn Int#
x2

-- Requires x2 <= x1
{-# INLINE [0] efdtIntDnFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtIntDnFB :: (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntDnFB :: forall r. (Int -> r -> r) -> r -> Int# -> Int# -> Int# -> r
efdtIntDnFB Int -> r -> r
c r
n Int#
x1 Int#
x2 Int#
y    -- Be careful about underflow!
 | Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
># Int#
x2) = if Int# -> Bool
isTrue# (Int#
y Int# -> Int# -> Int#
># Int#
x1) then r
n else Int# -> Int
I# Int#
x1 Int -> r -> r
`c` r
n
 | Bool
otherwise = -- Common case: x1 >= x2 >= y
               let !delta :: Int#
delta = Int#
x2 Int# -> Int# -> Int#
-# Int#
x1 -- <= 0
                   !y' :: Int#
y' = Int#
y Int# -> Int# -> Int#
-# Int#
delta  -- y <= y' <= x1; hence y' is representable

                   -- Invariant: x >= y
                   -- Note that: z >= y' => z + delta won't underflow
                   -- so we are guaranteed not to underflow if/when we recurse
                   go_dn :: Int# -> r
go_dn Int#
x | Int# -> Bool
isTrue# (Int#
x Int# -> Int# -> Int#
<# Int#
y') = Int# -> Int
I# Int#
x Int -> r -> r
`c` r
n
                           | Bool
otherwise         = Int# -> Int
I# Int#
x Int -> r -> r
`c` Int# -> r
go_dn (Int#
x Int# -> Int# -> Int#
+# Int#
delta)
               in Int# -> Int
I# Int#
x1 Int -> r -> r
`c` Int# -> r
go_dn Int#
x2


------------------------------------------------------------------------
-- Word
------------------------------------------------------------------------

-- | @since base-2.01
instance Bounded Word where
    minBound :: Word
minBound = Word
0

    -- use unboxed literals for maxBound, because GHC doesn't optimise
    -- (fromInteger 0xffffffff :: Word).
#if WORD_SIZE_IN_BITS == 32
    maxBound = W# 0xFFFFFFFF##
#elif WORD_SIZE_IN_BITS == 64
    maxBound :: Word
maxBound = Word# -> Word
W# Word#
0xFFFFFFFFFFFFFFFF##
#else
#error Unhandled value for WORD_SIZE_IN_BITS
#endif

-- | @since base-2.01
instance Enum Word where
    succ :: Word -> Word
succ Word
x
        | Word
x Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
/= Word
forall a. Bounded a => a
maxBound = Word
x Word -> Word -> Word
forall a. Num a => a -> a -> a
+ Word
1
        | Bool
otherwise     = String -> Word
forall a. String -> a
succError String
"Word"
    pred :: Word -> Word
pred Word
x
        | Word
x Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
/= Word
forall a. Bounded a => a
minBound = Word
x Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1
        | Bool
otherwise     = String -> Word
forall a. String -> a
predError String
"Word"
    toEnum :: Int -> Word
toEnum i :: Int
i@(I# Int#
i#)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0        = Word# -> Word
W# (Int# -> Word#
int2Word# Int#
i#)
        | Bool
otherwise     = String -> Int -> (Word, Word) -> Word
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Word" Int
i (Word
forall a. Bounded a => a
minBound::Word, Word
forall a. Bounded a => a
maxBound::Word)
    fromEnum :: Word -> Int
fromEnum x :: Word
x@(W# Word#
x#)
        | Word
x Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
<= Word
maxIntWord = Int# -> Int
I# (Word# -> Int#
word2Int# Word#
x#)
        | Bool
otherwise       = String -> Word -> Int
forall a b. Show a => String -> a -> b
fromEnumError String
"Word" Word
x

    {-# INLINE enumFrom #-}
    enumFrom :: Word -> [Word]
enumFrom (W# Word#
x#)      = Word# -> Word# -> [Word]
eftWord Word#
x# Word#
maxWord#
        where !(W# Word#
maxWord#) = Word
forall a. Bounded a => a
maxBound
        -- Blarg: technically I guess enumFrom isn't strict!

    {-# INLINE enumFromTo #-}
    enumFromTo :: Word -> Word -> [Word]
enumFromTo (W# Word#
x) (W# Word#
y) = Word# -> Word# -> [Word]
eftWord Word#
x Word#
y

    {-# INLINE enumFromThen #-}
    enumFromThen :: Word -> Word -> [Word]
enumFromThen (W# Word#
x1) (W# Word#
x2) = Word# -> Word# -> [Word]
efdWord Word#
x1 Word#
x2

    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: Word -> Word -> Word -> [Word]
enumFromThenTo (W# Word#
x1) (W# Word#
x2) (W# Word#
y) = Word# -> Word# -> Word# -> [Word]
efdtWord Word#
x1 Word#
x2 Word#
y

maxIntWord :: Word
-- The biggest word representable as an Int
maxIntWord :: Word
maxIntWord = Word# -> Word
W# (case Int
maxInt of I# Int#
i -> Int# -> Word#
int2Word# Int#
i)

-----------------------------------------------------
-- eftWord and eftWordFB deal with [a..b], which is the
-- most common form, so we take a lot of care
-- In particular, we have rules for deforestation

{-# RULES
"eftWord"        [~1] forall x y. eftWord x y = build (\ c n -> eftWordFB c n x y)
"eftWordList"    [1] eftWordFB  (:) [] = eftWord
 #-}

-- The Enum rules for Word work much the same way that they do for Int.
-- See Note [How the Enum rules work].

{-# NOINLINE [1] eftWord #-}
eftWord :: Word# -> Word# -> [Word]
-- [x1..x2]
eftWord :: Word# -> Word# -> [Word]
eftWord Word#
x0 Word#
y | Int# -> Bool
isTrue# (Word#
x0 Word# -> Word# -> Int#
`gtWord#` Word#
y) = []
             | Bool
otherwise                = Word# -> [Word]
go Word#
x0
                where
                  go :: Word# -> [Word]
go Word#
x = Word# -> Word
W# Word#
x Word -> [Word] -> [Word]
forall a. a -> [a] -> [a]
: if Int# -> Bool
isTrue# (Word#
x Word# -> Word# -> Int#
`eqWord#` Word#
y)
                                then []
                                else Word# -> [Word]
go (Word#
x Word# -> Word# -> Word#
`plusWord#` Word#
1##)

{-# INLINE [0] eftWordFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
eftWordFB :: (Word -> r -> r) -> r -> Word# -> Word# -> r
eftWordFB :: forall r. (Word -> r -> r) -> r -> Word# -> Word# -> r
eftWordFB Word -> r -> r
c r
n Word#
x0 Word#
y | Int# -> Bool
isTrue# (Word#
x0 Word# -> Word# -> Int#
`gtWord#` Word#
y) = r
n
                   | Bool
otherwise                = Word# -> r
go Word#
x0
                  where
                    go :: Word# -> r
go Word#
x = Word# -> Word
W# Word#
x Word -> r -> r
`c` if Int# -> Bool
isTrue# (Word#
x Word# -> Word# -> Int#
`eqWord#` Word#
y)
                                    then r
n
                                    else Word# -> r
go (Word#
x Word# -> Word# -> Word#
`plusWord#` Word#
1##)
                        -- Watch out for y=maxBound; hence ==, not >
        -- Be very careful not to have more than one "c"
        -- so that when eftInfFB is inlined we can inline
        -- whatever is bound to "c"


-----------------------------------------------------
-- efdWord and efdtWord deal with [a,b..] and [a,b..c].
-- The code is more complicated because of worries about Word overflow.

-- See Note [How the Enum rules work]
{-# RULES
"efdtWord"       [~1] forall x1 x2 y.
                     efdtWord x1 x2 y = build (\ c n -> efdtWordFB c n x1 x2 y)
"efdtWordUpList" [1]  efdtWordFB (:) [] = efdtWord
 #-}

efdWord :: Word# -> Word# -> [Word]
-- [x1,x2..maxWord]
efdWord :: Word# -> Word# -> [Word]
efdWord Word#
x1 Word#
x2
 | Int# -> Bool
isTrue# (Word#
x2 Word# -> Word# -> Int#
`geWord#` Word#
x1) = case Word
forall a. Bounded a => a
maxBound of W# Word#
y -> Word# -> Word# -> Word# -> [Word]
efdtWordUp Word#
x1 Word#
x2 Word#
y
 | Bool
otherwise                 = case Word
forall a. Bounded a => a
minBound of W# Word#
y -> Word# -> Word# -> Word# -> [Word]
efdtWordDn Word#
x1 Word#
x2 Word#
y

{-# NOINLINE [1] efdtWord #-}
efdtWord :: Word# -> Word# -> Word# -> [Word]
-- [x1,x2..y]
efdtWord :: Word# -> Word# -> Word# -> [Word]
efdtWord Word#
x1 Word#
x2 Word#
y
 | Int# -> Bool
isTrue# (Word#
x2 Word# -> Word# -> Int#
`geWord#` Word#
x1) = Word# -> Word# -> Word# -> [Word]
efdtWordUp Word#
x1 Word#
x2 Word#
y
 | Bool
otherwise                 = Word# -> Word# -> Word# -> [Word]
efdtWordDn Word#
x1 Word#
x2 Word#
y

{-# INLINE [0] efdtWordFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtWordFB :: (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordFB :: forall r. (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordFB Word -> r -> r
c r
n Word#
x1 Word#
x2 Word#
y
 | Int# -> Bool
isTrue# (Word#
x2 Word# -> Word# -> Int#
`geWord#` Word#
x1) = (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
forall r. (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordUpFB Word -> r -> r
c r
n Word#
x1 Word#
x2 Word#
y
 | Bool
otherwise                 = (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
forall r. (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordDnFB Word -> r -> r
c r
n Word#
x1 Word#
x2 Word#
y

-- Requires x2 >= x1
efdtWordUp :: Word# -> Word# -> Word# -> [Word]
efdtWordUp :: Word# -> Word# -> Word# -> [Word]
efdtWordUp Word#
x1 Word#
x2 Word#
y    -- Be careful about overflow!
 | Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`ltWord#` Word#
x2) = if Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`ltWord#` Word#
x1) then [] else [Word# -> Word
W# Word#
x1]
 | Bool
otherwise = -- Common case: x1 <= x2 <= y
               let !delta :: Word#
delta = Word#
x2 Word# -> Word# -> Word#
`minusWord#` Word#
x1 -- >= 0
                   !y' :: Word#
y' = Word#
y Word# -> Word# -> Word#
`minusWord#` Word#
delta  -- x1 <= y' <= y; hence y' is representable

                   -- Invariant: x <= y
                   -- Note that: z <= y' => z + delta won't overflow
                   -- so we are guaranteed not to overflow if/when we recurse
                   go_up :: Word# -> [Word]
go_up Word#
x | Int# -> Bool
isTrue# (Word#
x Word# -> Word# -> Int#
`gtWord#` Word#
y') = [Word# -> Word
W# Word#
x]
                           | Bool
otherwise                = Word# -> Word
W# Word#
x Word -> [Word] -> [Word]
forall a. a -> [a] -> [a]
: Word# -> [Word]
go_up (Word#
x Word# -> Word# -> Word#
`plusWord#` Word#
delta)
               in Word# -> Word
W# Word#
x1 Word -> [Word] -> [Word]
forall a. a -> [a] -> [a]
: Word# -> [Word]
go_up Word#
x2

-- Requires x2 >= x1
{-# INLINE [0] efdtWordUpFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtWordUpFB :: (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordUpFB :: forall r. (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordUpFB Word -> r -> r
c r
n Word#
x1 Word#
x2 Word#
y    -- Be careful about overflow!
 | Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`ltWord#` Word#
x2) = if Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`ltWord#` Word#
x1) then r
n else Word# -> Word
W# Word#
x1 Word -> r -> r
`c` r
n
 | Bool
otherwise = -- Common case: x1 <= x2 <= y
               let !delta :: Word#
delta = Word#
x2 Word# -> Word# -> Word#
`minusWord#` Word#
x1 -- >= 0
                   !y' :: Word#
y' = Word#
y Word# -> Word# -> Word#
`minusWord#` Word#
delta  -- x1 <= y' <= y; hence y' is representable

                   -- Invariant: x <= y
                   -- Note that: z <= y' => z + delta won't overflow
                   -- so we are guaranteed not to overflow if/when we recurse
                   go_up :: Word# -> r
go_up Word#
x | Int# -> Bool
isTrue# (Word#
x Word# -> Word# -> Int#
`gtWord#` Word#
y') = Word# -> Word
W# Word#
x Word -> r -> r
`c` r
n
                           | Bool
otherwise                = Word# -> Word
W# Word#
x Word -> r -> r
`c` Word# -> r
go_up (Word#
x Word# -> Word# -> Word#
`plusWord#` Word#
delta)
               in Word# -> Word
W# Word#
x1 Word -> r -> r
`c` Word# -> r
go_up Word#
x2

-- Requires x2 <= x1
efdtWordDn :: Word# -> Word# -> Word# -> [Word]
efdtWordDn :: Word# -> Word# -> Word# -> [Word]
efdtWordDn Word#
x1 Word#
x2 Word#
y    -- Be careful about underflow!
 | Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`gtWord#` Word#
x2) = if Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`gtWord#` Word#
x1) then [] else [Word# -> Word
W# Word#
x1]
 | Bool
otherwise = -- Common case: x1 >= x2 >= y
               let !delta :: Word#
delta = Word#
x2 Word# -> Word# -> Word#
`minusWord#` Word#
x1 -- <= 0
                   !y' :: Word#
y' = Word#
y Word# -> Word# -> Word#
`minusWord#` Word#
delta  -- y <= y' <= x1; hence y' is representable

                   -- Invariant: x >= y
                   -- Note that: z >= y' => z + delta won't underflow
                   -- so we are guaranteed not to underflow if/when we recurse
                   go_dn :: Word# -> [Word]
go_dn Word#
x | Int# -> Bool
isTrue# (Word#
x Word# -> Word# -> Int#
`ltWord#` Word#
y') = [Word# -> Word
W# Word#
x]
                           | Bool
otherwise                = Word# -> Word
W# Word#
x Word -> [Word] -> [Word]
forall a. a -> [a] -> [a]
: Word# -> [Word]
go_dn (Word#
x Word# -> Word# -> Word#
`plusWord#` Word#
delta)
   in Word# -> Word
W# Word#
x1 Word -> [Word] -> [Word]
forall a. a -> [a] -> [a]
: Word# -> [Word]
go_dn Word#
x2

-- Requires x2 <= x1
{-# INLINE [0] efdtWordDnFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtWordDnFB :: (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordDnFB :: forall r. (Word -> r -> r) -> r -> Word# -> Word# -> Word# -> r
efdtWordDnFB Word -> r -> r
c r
n Word#
x1 Word#
x2 Word#
y    -- Be careful about underflow!
 | Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`gtWord#` Word#
x2) = if Int# -> Bool
isTrue# (Word#
y Word# -> Word# -> Int#
`gtWord#` Word#
x1) then r
n else Word# -> Word
W# Word#
x1 Word -> r -> r
`c` r
n
 | Bool
otherwise = -- Common case: x1 >= x2 >= y
               let !delta :: Word#
delta = Word#
x2 Word# -> Word# -> Word#
`minusWord#` Word#
x1 -- <= 0
                   !y' :: Word#
y' = Word#
y Word# -> Word# -> Word#
`minusWord#` Word#
delta  -- y <= y' <= x1; hence y' is representable

                   -- Invariant: x >= y
                   -- Note that: z >= y' => z + delta won't underflow
                   -- so we are guaranteed not to underflow if/when we recurse
                   go_dn :: Word# -> r
go_dn Word#
x | Int# -> Bool
isTrue# (Word#
x Word# -> Word# -> Int#
`ltWord#` Word#
y') = Word# -> Word
W# Word#
x Word -> r -> r
`c` r
n
                           | Bool
otherwise                = Word# -> Word
W# Word#
x Word -> r -> r
`c` Word# -> r
go_dn (Word#
x Word# -> Word# -> Word#
`plusWord#` Word#
delta)
               in Word# -> Word
W# Word#
x1 Word -> r -> r
`c` Word# -> r
go_dn Word#
x2

------------------------------------------------------------------------
-- Integer
------------------------------------------------------------------------

-- | @since base-2.01
instance  Enum Integer  where
    succ :: Integer -> Integer
succ Integer
x               = Integer
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1
    pred :: Integer -> Integer
pred Integer
x               = Integer
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1
    toEnum :: Int -> Integer
toEnum (I# Int#
n)        = Int# -> Integer
IS Int#
n
    fromEnum :: Integer -> Int
fromEnum Integer
n           = Integer -> Int
integerToInt Integer
n

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFrom #-}
    enumFrom :: Integer -> [Integer]
enumFrom Integer
x = Integer -> Integer -> [Integer]
enumDeltaInteger Integer
x Integer
1

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThen #-}
    enumFromThen :: Integer -> Integer -> [Integer]
enumFromThen Integer
x Integer
y = Integer -> Integer -> [Integer]
enumDeltaInteger Integer
x (Integer
yInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
-Integer
x)

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromTo #-}
    enumFromTo :: Integer -> Integer -> [Integer]
enumFromTo Integer
x Integer
lim = Integer -> Integer -> Integer -> [Integer]
enumDeltaToInteger Integer
x Integer
1 Integer
lim

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]
enumFromThenTo Integer
x Integer
y Integer
lim = Integer -> Integer -> Integer -> [Integer]
enumDeltaToInteger Integer
x (Integer
yInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
-Integer
x) Integer
lim

-- See Note [How the Enum rules work]
{-# RULES
"enumDeltaInteger"      [~1] forall x y.   enumDeltaInteger x y         = build (\c _ -> enumDeltaIntegerFB c x y)
"efdtInteger"           [~1] forall x d l. enumDeltaToInteger x d l     = build (\c n -> enumDeltaToIntegerFB  c n x d l)
"efdtInteger1"          [~1] forall x l.   enumDeltaToInteger x 1 l     = build (\c n -> enumDeltaToInteger1FB c n x l)

"enumDeltaToInteger1FB" [1] forall c n x.  enumDeltaToIntegerFB c n x 1 = enumDeltaToInteger1FB c n x

"enumDeltaInteger"      [1] enumDeltaIntegerFB    (:)     = enumDeltaInteger
"enumDeltaToInteger"    [1] enumDeltaToIntegerFB  (:) []  = enumDeltaToInteger
"enumDeltaToInteger1"   [1] enumDeltaToInteger1FB (:) []  = enumDeltaToInteger1
 #-}

{- Note [Enum Integer rules for literal 1]
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The "1" rules above specialise for the common case where delta = 1,
so that we can avoid the delta>=0 test in enumDeltaToIntegerFB.
Then enumDeltaToInteger1FB is nice and small and can be inlined,
which would allow the constructor to be inlined and good things to happen.

We match on the literal "1" both in phase 2 (rule "efdtInteger1") and
phase 1 (rule "enumDeltaToInteger1FB"), just for belt and braces

We do not do it for Int this way because hand-tuned code already exists, and
the special case varies more from the general case, due to the issue of overflows.
-}

{-# INLINE [0] enumDeltaIntegerFB #-}
-- See Note [Inline FB functions] in GHC.Internal.List
enumDeltaIntegerFB :: (Integer -> b -> b) -> Integer -> Integer -> b
enumDeltaIntegerFB :: forall b. (Integer -> b -> b) -> Integer -> Integer -> b
enumDeltaIntegerFB Integer -> b -> b
c Integer
x0 Integer
d = Integer -> b
go Integer
x0
  where go :: Integer -> b
go Integer
x = Integer
x Integer -> b -> b
forall a b. a -> b -> b
`seq` (Integer
x Integer -> b -> b
`c` Integer -> b
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
d))

{-# NOINLINE [1] enumDeltaInteger #-} -- Inline after rule "enumDeltaInteger" is inactive
enumDeltaInteger :: Integer -> Integer -> [Integer]
enumDeltaInteger :: Integer -> Integer -> [Integer]
enumDeltaInteger Integer
x Integer
d = Integer
x Integer -> [Integer] -> [Integer]
forall a b. a -> b -> b
`seq` (Integer
x Integer -> [Integer] -> [Integer]
forall a. a -> [a] -> [a]
: Integer -> Integer -> [Integer]
enumDeltaInteger (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
d) Integer
d)
-- strict accumulator, so
--     head (drop 1000000 [1 .. ]
-- works

{-# INLINE [0] enumDeltaToIntegerFB #-}
-- See Note [Inline FB functions] in GHC.Internal.List
-- Don't inline this until RULE "enumDeltaToInteger" has had a chance to fire
enumDeltaToIntegerFB :: (Integer -> a -> a) -> a
                     -> Integer -> Integer -> Integer -> a
enumDeltaToIntegerFB :: forall a.
(Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
enumDeltaToIntegerFB Integer -> a -> a
c a
n Integer
x Integer
delta Integer
lim
  | Integer
delta Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0 = (Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
forall a.
(Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
up_fb Integer -> a -> a
c a
n Integer
x Integer
delta Integer
lim
  | Bool
otherwise  = (Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
forall a.
(Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
dn_fb Integer -> a -> a
c a
n Integer
x Integer
delta Integer
lim

{-# INLINE [0] enumDeltaToInteger1FB #-}
-- See Note [Inline FB functions] in GHC.Internal.List
-- Don't inline this until RULE "enumDeltaToInteger" has had a chance to fire
enumDeltaToInteger1FB :: (Integer -> a -> a) -> a
                      -> Integer -> Integer -> a
enumDeltaToInteger1FB :: forall a. (Integer -> a -> a) -> a -> Integer -> Integer -> a
enumDeltaToInteger1FB Integer -> a -> a
c a
n Integer
x0 Integer
lim = Integer -> a
go (Integer
x0 :: Integer)
                      where
                        go :: Integer -> a
go Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
lim   = a
n
                             | Bool
otherwise = Integer
x Integer -> a -> a
`c` Integer -> a
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)

{-# NOINLINE [1] enumDeltaToInteger #-} -- Inline after rule "efdtInteger" is inactive
enumDeltaToInteger :: Integer -> Integer -> Integer -> [Integer]
enumDeltaToInteger :: Integer -> Integer -> Integer -> [Integer]
enumDeltaToInteger Integer
x Integer
delta Integer
lim
  | Integer
delta Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0 = Integer -> Integer -> Integer -> [Integer]
up_list Integer
x Integer
delta Integer
lim
  | Bool
otherwise  = Integer -> Integer -> Integer -> [Integer]
dn_list Integer
x Integer
delta Integer
lim

{-# NOINLINE [1] enumDeltaToInteger1 #-} -- Inline after rule "efdtInteger1" is inactive
enumDeltaToInteger1 :: Integer -> Integer -> [Integer]
-- Special case for Delta = 1
enumDeltaToInteger1 :: Integer -> Integer -> [Integer]
enumDeltaToInteger1 Integer
x0 Integer
lim = Integer -> [Integer]
go (Integer
x0 :: Integer)
                      where
                        go :: Integer -> [Integer]
go Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
lim   = []
                             | Bool
otherwise = Integer
x Integer -> [Integer] -> [Integer]
forall a. a -> [a] -> [a]
: Integer -> [Integer]
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)

up_fb :: (Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
up_fb :: forall a.
(Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
up_fb Integer -> a -> a
c a
n Integer
x0 Integer
delta Integer
lim = Integer -> a
go (Integer
x0 :: Integer)
                      where
                        go :: Integer -> a
go Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
lim   = a
n
                             | Bool
otherwise = Integer
x Integer -> a -> a
`c` Integer -> a
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
delta)
dn_fb :: (Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
dn_fb :: forall a.
(Integer -> a -> a) -> a -> Integer -> Integer -> Integer -> a
dn_fb Integer -> a -> a
c a
n Integer
x0 Integer
delta Integer
lim = Integer -> a
go (Integer
x0 :: Integer)
                      where
                        go :: Integer -> a
go Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
lim   = a
n
                             | Bool
otherwise = Integer
x Integer -> a -> a
`c` Integer -> a
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
delta)

up_list :: Integer -> Integer -> Integer -> [Integer]
up_list :: Integer -> Integer -> Integer -> [Integer]
up_list Integer
x0 Integer
delta Integer
lim = Integer -> [Integer]
go (Integer
x0 :: Integer)
                    where
                        go :: Integer -> [Integer]
go Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
lim   = []
                             | Bool
otherwise = Integer
x Integer -> [Integer] -> [Integer]
forall a. a -> [a] -> [a]
: Integer -> [Integer]
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
delta)
dn_list :: Integer -> Integer -> Integer -> [Integer]
dn_list :: Integer -> Integer -> Integer -> [Integer]
dn_list Integer
x0 Integer
delta Integer
lim = Integer -> [Integer]
go (Integer
x0 :: Integer)
                    where
                        go :: Integer -> [Integer]
go Integer
x | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
lim   = []
                             | Bool
otherwise = Integer
x Integer -> [Integer] -> [Integer]
forall a. a -> [a] -> [a]
: Integer -> [Integer]
go (Integer
xInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
delta)

------------------------------------------------------------------------
-- Natural
------------------------------------------------------------------------

-- | @since base-4.8.0.0
instance Enum Natural where
    succ :: Natural -> Natural
succ Natural
n = Natural
n Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ Natural
1
    pred :: Natural -> Natural
pred Natural
n = Natural
n Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
- Natural
1
    toEnum :: Int -> Natural
toEnum i :: Int
i@(I# Int#
i#)
      | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0    = Word# -> Natural
naturalFromWord# (Int# -> Word#
int2Word# Int#
i#)
      | Bool
otherwise = String -> Natural
forall a. String -> a
errorWithoutStackTrace String
"toEnum: unexpected negative Int"

    fromEnum :: Natural -> Int
fromEnum (NS Word#
w) | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 = Int
i
      where
        i :: Int
i = Int# -> Int
I# (Word# -> Int#
word2Int# Word#
w)
    fromEnum Natural
_ = String -> Int
forall a. String -> a
errorWithoutStackTrace String
"fromEnum: out of Int range"

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFrom #-}
    enumFrom :: Natural -> [Natural]
enumFrom Natural
x        = Natural -> Natural -> [Natural]
enumDeltaNatural      Natural
x Natural
1

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThen #-}
    enumFromThen :: Natural -> Natural -> [Natural]
enumFromThen Natural
x Natural
y
      | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
y        = Natural -> Natural -> [Natural]
enumDeltaNatural      Natural
x (Natural
yNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
-Natural
x)
      | Bool
otherwise     = Natural -> Natural -> Natural -> [Natural]
enumNegDeltaToNatural Natural
x (Natural
xNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
-Natural
y) Natural
0

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromTo #-}
    enumFromTo :: Natural -> Natural -> [Natural]
enumFromTo Natural
x Natural
lim  = Natural -> Natural -> Natural -> [Natural]
enumDeltaToNatural    Natural
x Natural
1 Natural
lim

    -- See Note [Stable Unfolding for list producers]
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: Natural -> Natural -> Natural -> [Natural]
enumFromThenTo Natural
x Natural
y Natural
lim
      | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
<= Natural
y        = Natural -> Natural -> Natural -> [Natural]
enumDeltaToNatural    Natural
x (Natural
yNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
-Natural
x) Natural
lim
      | Bool
otherwise     = Natural -> Natural -> Natural -> [Natural]
enumNegDeltaToNatural Natural
x (Natural
xNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
-Natural
y) Natural
lim

-- Helpers for 'Enum Natural'; TODO: optimise & make fusion work

enumDeltaNatural :: Natural -> Natural -> [Natural]
enumDeltaNatural :: Natural -> Natural -> [Natural]
enumDeltaNatural !Natural
x Natural
d = Natural
x Natural -> [Natural] -> [Natural]
forall a. a -> [a] -> [a]
: Natural -> Natural -> [Natural]
enumDeltaNatural (Natural
xNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
+Natural
d) Natural
d

-- Inline to specialize
{-# INLINE enumDeltaToNatural #-}
enumDeltaToNatural :: Natural -> Natural -> Natural -> [Natural]
enumDeltaToNatural :: Natural -> Natural -> Natural -> [Natural]
enumDeltaToNatural Natural
x0 Natural
delta Natural
lim = Natural -> [Natural]
go Natural
x0
  where
    go :: Natural -> [Natural]
go Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
> Natural
lim   = []
         | Bool
otherwise = Natural
x Natural -> [Natural] -> [Natural]
forall a. a -> [a] -> [a]
: Natural -> [Natural]
go (Natural
xNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
+Natural
delta)

-- Inline to specialize
{-# INLINE enumNegDeltaToNatural #-}
enumNegDeltaToNatural :: Natural -> Natural -> Natural -> [Natural]
enumNegDeltaToNatural :: Natural -> Natural -> Natural -> [Natural]
enumNegDeltaToNatural Natural
x0 Natural
ndelta Natural
lim = Natural -> [Natural]
go Natural
x0
  where
    go :: Natural -> [Natural]
go Natural
x | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
< Natural
lim     = []
         | Natural
x Natural -> Natural -> Bool
forall a. Ord a => a -> a -> Bool
>= Natural
ndelta = Natural
x Natural -> [Natural] -> [Natural]
forall a. a -> [a] -> [a]
: Natural -> [Natural]
go (Natural
xNatural -> Natural -> Natural
forall a. Num a => a -> a -> a
-Natural
ndelta)
         | Bool
otherwise   = [Natural
x]

-- | Convert an Int into a Word (used in derived Enum instances)
enumIntToWord :: Int -> Word
enumIntToWord :: Int -> Word
enumIntToWord (I# Int#
i) = Word# -> Word
W# (Int# -> Word#
int2Word# Int#
i)

-- Instances from GHC.Types

-- | @since base-4.16.0.0
deriving instance Bounded Levity
-- | @since base-4.16.0.0
deriving instance Enum Levity

-- | @since base-4.10.0.0
deriving instance Bounded VecCount
-- | @since base-4.10.0.0
deriving instance Enum VecCount

-- | @since base-4.10.0.0
deriving instance Bounded VecElem
-- | @since base-4.10.0.0
deriving instance Enum VecElem