{-# OPTIONS_GHC -Wall -fwarn-tabs -XMagicHash #-}
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 701
{-# LANGUAGE Trustworthy #-}
#endif
module Prelude.SafeEnum
( UpwardEnum(..)
, DownwardEnum(..)
, Enum(..)
) where
import Prelude hiding (Enum(..))
import qualified Prelude (Enum(..))
#ifdef __GLASGOW_HASKELL__
# if __GLASGOW_HASKELL__ >= 708
import GHC.Exts (isTrue#, (/=#))
# else
import GHC.Exts ((==#))
# endif
import GHC.Exts (build, Int(I#), Char(C#), ord#, chr#, (<=#), (+#), (-#), leChar#)
#else
import Data.Char (chr, ord)
#endif
infix 4 `precedes`, `succeeds`
class UpwardEnum a where
succ :: a -> Maybe a
succeeds :: a -> a -> Bool
enumFrom :: a -> [a]
#ifdef __GLASGOW_HASKELL__
{-# INLINE enumFrom #-}
enumFrom a
x0 = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (a -> (a -> b -> b) -> b -> b
forall t t. UpwardEnum t => t -> (t -> t -> t) -> t -> t
enumFromFB a
x0)
where
{-# INLINE [0] enumFromFB #-}
enumFromFB :: t -> (t -> t -> t) -> t -> t
enumFromFB t
x t -> t -> t
cons t
nil = t
x t -> t -> t
`cons`
case t -> Maybe t
forall a. UpwardEnum a => a -> Maybe a
succ t
x of
Maybe t
Nothing -> t
nil
Just t
y -> t -> (t -> t -> t) -> t -> t
enumFromFB t
y t -> t -> t
cons t
nil
#else
enumFrom x = x :
case succ x of
Nothing -> []
Just y -> enumFrom y
#endif
enumFromTo :: a -> a -> [a]
#ifdef __GLASGOW_HASKELL__
{-# INLINE enumFromTo #-}
enumFromTo a
x0 a
z0 = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (a -> a -> (a -> b -> b) -> b -> b
forall t t. UpwardEnum t => t -> t -> (t -> t -> t) -> t -> t
enumFromToFB a
x0 a
z0)
where
{-# INLINE [0] enumFromToFB #-}
enumFromToFB :: t -> t -> (t -> t -> t) -> t -> t
enumFromToFB t
x t
z t -> t -> t
cons t
nil
| t
x t -> t -> Bool
forall a. UpwardEnum a => a -> a -> Bool
`succeeds` t
z = t
nil
| Bool
otherwise = t
x t -> t -> t
`cons`
case t -> Maybe t
forall a. UpwardEnum a => a -> Maybe a
succ t
x of
Maybe t
Nothing -> t
nil
Just t
y -> t -> t -> (t -> t -> t) -> t -> t
enumFromToFB t
y t
z t -> t -> t
cons t
nil
#else
enumFromTo x z
| x `succeeds` z = []
| otherwise = x :
case succ x of
Nothing -> []
Just y -> enumFromTo y z
#endif
class DownwardEnum a where
pred :: a -> Maybe a
precedes :: a -> a -> Bool
enumDownFrom :: a -> [a]
#ifdef __GLASGOW_HASKELL__
{-# INLINE enumDownFrom #-}
enumDownFrom a
x0 = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (a -> (a -> b -> b) -> b -> b
forall t t. DownwardEnum t => t -> (t -> t -> t) -> t -> t
enumDownFromFB a
x0)
where
{-# INLINE [0] enumDownFromFB #-}
enumDownFromFB :: t -> (t -> t -> t) -> t -> t
enumDownFromFB t
x t -> t -> t
cons t
nil = t
x t -> t -> t
`cons`
case t -> Maybe t
forall a. DownwardEnum a => a -> Maybe a
pred t
x of
Maybe t
Nothing -> t
nil
Just t
y -> t -> (t -> t -> t) -> t -> t
enumDownFromFB t
y t -> t -> t
cons t
nil
#else
enumDownFrom x = x :
case pred x of
Nothing -> []
Just y -> enumDownFrom y
#endif
enumDownFromTo :: a -> a -> [a]
#ifdef __GLASGOW_HASKELL__
{-# INLINE enumDownFromTo #-}
enumDownFromTo a
x0 a
z0 = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (a -> a -> (a -> b -> b) -> b -> b
forall t t. DownwardEnum t => t -> t -> (t -> t -> t) -> t -> t
enumDownFromToFB a
x0 a
z0)
where
{-# INLINE [0] enumDownFromToFB #-}
enumDownFromToFB :: t -> t -> (t -> t -> t) -> t -> t
enumDownFromToFB t
x t
z t -> t -> t
cons t
nil
| t
x t -> t -> Bool
forall a. DownwardEnum a => a -> a -> Bool
`precedes` t
z = t
nil
| Bool
otherwise = t
x t -> t -> t
`cons`
case t -> Maybe t
forall a. DownwardEnum a => a -> Maybe a
pred t
x of
Maybe t
Nothing -> t
nil
Just t
y -> t -> t -> (t -> t -> t) -> t -> t
enumDownFromToFB t
y t
z t -> t -> t
cons t
nil
#else
enumDownFromTo x z
| x `precedes` z = []
| otherwise = x :
case pred x of
Nothing -> []
Just y -> enumDownFromTo y z
#endif
class (UpwardEnum a, DownwardEnum a) => Enum a where
toEnum :: Int -> Maybe a
:: a -> Maybe Int
enumFromThen :: a -> a -> [a]
enumFromThen a
x a
y =
[a] -> ([a] -> [a]) -> Maybe [a] -> [a]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [a
x] [a] -> [a]
forall a. a -> a
id (Maybe [a] -> [a]) -> Maybe [a] -> [a]
forall a b. (a -> b) -> a -> b
$! do
Int
x' <- a -> Maybe Int
forall a. Enum a => a -> Maybe Int
fromEnum a
x
Int
y' <- a -> Maybe Int
forall a. Enum a => a -> Maybe Int
fromEnum a
y
[a] -> Maybe [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> Maybe [a]) -> [a] -> Maybe [a]
forall a b. (a -> b) -> a -> b
$! [Int] -> [a]
forall a. Enum a => [Int] -> [a]
takeEnum (Int -> Int -> [Int]
forall a. Enum a => a -> a -> [a]
enumFromThen Int
x' Int
y')
enumFromThenTo :: a -> a -> a -> [a]
enumFromThenTo a
x a
y a
z
| a
x a -> a -> Bool
forall a. DownwardEnum a => a -> a -> Bool
`precedes` a
y Bool -> Bool -> Bool
&& a
x a -> a -> Bool
forall a. UpwardEnum a => a -> a -> Bool
`succeeds` a
z = []
| a
x a -> a -> Bool
forall a. UpwardEnum a => a -> a -> Bool
`succeeds` a
y Bool -> Bool -> Bool
&& a
x a -> a -> Bool
forall a. DownwardEnum a => a -> a -> Bool
`precedes` a
z = []
| Bool
otherwise =
[a] -> ([a] -> [a]) -> Maybe [a] -> [a]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [a
x] [a] -> [a]
forall a. a -> a
id (Maybe [a] -> [a]) -> Maybe [a] -> [a]
forall a b. (a -> b) -> a -> b
$! do
Int
x' <- a -> Maybe Int
forall a. Enum a => a -> Maybe Int
fromEnum a
x
Int
y' <- a -> Maybe Int
forall a. Enum a => a -> Maybe Int
fromEnum a
y
Int
z' <- a -> Maybe Int
forall a. Enum a => a -> Maybe Int
fromEnum a
z
[a] -> Maybe [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> Maybe [a]) -> [a] -> Maybe [a]
forall a b. (a -> b) -> a -> b
$! [Int] -> [a]
forall a. Enum a => [Int] -> [a]
takeEnum (Int -> Int -> Int -> [Int]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Int
x' Int
y' Int
z')
takeEnum :: Enum a => [Int] -> [a]
#ifdef __GLASGOW_HASKELL__
{-# INLINE takeEnum #-}
takeEnum :: [Int] -> [a]
takeEnum [Int]
xs0 = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\a -> b -> b
cons b
nil -> (Int -> b -> b) -> b -> [Int] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((a -> b -> b) -> b -> Int -> b -> b
forall t t p. Enum t => (t -> t -> p) -> p -> Int -> t -> p
takeEnumCons a -> b -> b
cons b
nil) b
nil [Int]
xs0)
where
{-# INLINE takeEnumCons #-}
takeEnumCons :: (t -> t -> p) -> p -> Int -> t -> p
takeEnumCons t -> t -> p
cons p
nil Int
x t
ys =
case Int -> Maybe t
forall a. Enum a => Int -> Maybe a
toEnum Int
x of
Maybe t
Nothing -> p
nil
Just t
y -> t
y t -> t -> p
`cons` t
ys
#else
takeEnum [] = []
takeEnum (x:xs) =
case toEnum x of
Nothing -> []
Just y -> y : takeEnum xs
#endif
preludeEnumDownFrom :: (DownwardEnum a, Prelude.Enum a) => a -> [a]
preludeEnumDownFrom :: a -> [a]
preludeEnumDownFrom a
x =
case a -> Maybe a
forall a. DownwardEnum a => a -> Maybe a
pred a
x of
Maybe a
Nothing -> [a
x]
Just a
y -> a -> a -> [a]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen a
x a
y
{-# INLINE preludeEnumDownFrom #-}
preludeEnumDownFromTo :: (DownwardEnum a, Prelude.Enum a) => a -> a -> [a]
preludeEnumDownFromTo :: a -> a -> [a]
preludeEnumDownFromTo a
x a
z =
case a -> Maybe a
forall a. DownwardEnum a => a -> Maybe a
pred a
x of
Maybe a
Nothing -> [a
x]
Just a
y -> a -> a -> a -> [a]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo a
x a
y a
z
{-# INLINE preludeEnumDownFromTo #-}
instance UpwardEnum () where
succ :: () -> Maybe ()
succ () = Maybe ()
forall a. Maybe a
Nothing
succeeds :: () -> () -> Bool
succeeds = () -> () -> Bool
forall a. Ord a => a -> a -> Bool
(>)
enumFrom :: () -> [()]
enumFrom = () -> [()]
forall a. Enum a => a -> [a]
Prelude.enumFrom
enumFromTo :: () -> () -> [()]
enumFromTo = () -> () -> [()]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromTo
{-# INLINE succ #-}
{-# INLINE succeeds #-}
{-# INLINE enumFrom #-}
{-# INLINE enumFromTo #-}
instance DownwardEnum () where
pred :: () -> Maybe ()
pred () = Maybe ()
forall a. Maybe a
Nothing
precedes :: () -> () -> Bool
precedes = () -> () -> Bool
forall a. Ord a => a -> a -> Bool
(<)
enumDownFrom :: () -> [()]
enumDownFrom = () -> [()]
forall a. (DownwardEnum a, Enum a) => a -> [a]
preludeEnumDownFrom
enumDownFromTo :: () -> () -> [()]
enumDownFromTo = () -> () -> [()]
forall a. (DownwardEnum a, Enum a) => a -> a -> [a]
preludeEnumDownFromTo
{-# INLINE pred #-}
{-# INLINE precedes #-}
{-# INLINE enumDownFrom #-}
{-# INLINE enumDownFromTo #-}
instance Enum () where
toEnum :: Int -> Maybe ()
toEnum Int
i
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = () -> Maybe ()
forall a. a -> Maybe a
Just ()
| Bool
otherwise = Maybe ()
forall a. Maybe a
Nothing
fromEnum :: () -> Maybe Int
fromEnum () = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
enumFromThen :: () -> () -> [()]
enumFromThen = () -> () -> [()]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen
enumFromThenTo :: () -> () -> () -> [()]
enumFromThenTo = () -> () -> () -> [()]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo
{-# INLINE toEnum #-}
{-# INLINE fromEnum #-}
{-# INLINE enumFromThen #-}
{-# INLINE enumFromThenTo #-}
instance UpwardEnum Bool where
succ :: Bool -> Maybe Bool
succ Bool
False = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
succ Bool
True = Maybe Bool
forall a. Maybe a
Nothing
succeeds :: Bool -> Bool -> Bool
succeeds = Bool -> Bool -> Bool
forall a. Ord a => a -> a -> Bool
(>)
enumFrom :: Bool -> [Bool]
enumFrom = Bool -> [Bool]
forall a. Enum a => a -> [a]
Prelude.enumFrom
enumFromTo :: Bool -> Bool -> [Bool]
enumFromTo = Bool -> Bool -> [Bool]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromTo
{-# INLINE succ #-}
{-# INLINE succeeds #-}
{-# INLINE enumFrom #-}
{-# INLINE enumFromTo #-}
instance DownwardEnum Bool where
pred :: Bool -> Maybe Bool
pred Bool
True = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
pred Bool
False = Maybe Bool
forall a. Maybe a
Nothing
precedes :: Bool -> Bool -> Bool
precedes = Bool -> Bool -> Bool
forall a. Ord a => a -> a -> Bool
(<)
enumDownFrom :: Bool -> [Bool]
enumDownFrom = Bool -> [Bool]
forall a. (DownwardEnum a, Enum a) => a -> [a]
preludeEnumDownFrom
enumDownFromTo :: Bool -> Bool -> [Bool]
enumDownFromTo = Bool -> Bool -> [Bool]
forall a. (DownwardEnum a, Enum a) => a -> a -> [a]
preludeEnumDownFromTo
{-# INLINE pred #-}
{-# INLINE precedes #-}
{-# INLINE enumDownFrom #-}
{-# INLINE enumDownFromTo #-}
instance Enum Bool where
toEnum :: Int -> Maybe Bool
toEnum Int
i
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
| Bool
otherwise = Maybe Bool
forall a. Maybe a
Nothing
fromEnum :: Bool -> Maybe Int
fromEnum Bool
False = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
fromEnum Bool
True = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1
enumFromThen :: Bool -> Bool -> [Bool]
enumFromThen = Bool -> Bool -> [Bool]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen
enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]
enumFromThenTo = Bool -> Bool -> Bool -> [Bool]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo
{-# INLINE toEnum #-}
{-# INLINE fromEnum #-}
{-# INLINE enumFromThen #-}
{-# INLINE enumFromThenTo #-}
instance UpwardEnum Ordering where
succ :: Ordering -> Maybe Ordering
succ Ordering
LT = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
EQ
succ Ordering
EQ = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
GT
succ Ordering
GT = Maybe Ordering
forall a. Maybe a
Nothing
succeeds :: Ordering -> Ordering -> Bool
succeeds = Ordering -> Ordering -> Bool
forall a. Ord a => a -> a -> Bool
(>)
enumFrom :: Ordering -> [Ordering]
enumFrom = Ordering -> [Ordering]
forall a. Enum a => a -> [a]
Prelude.enumFrom
enumFromTo :: Ordering -> Ordering -> [Ordering]
enumFromTo = Ordering -> Ordering -> [Ordering]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromTo
{-# INLINE succ #-}
{-# INLINE succeeds #-}
{-# INLINE enumFrom #-}
{-# INLINE enumFromTo #-}
instance DownwardEnum Ordering where
pred :: Ordering -> Maybe Ordering
pred Ordering
GT = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
EQ
pred Ordering
EQ = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
LT
pred Ordering
LT = Maybe Ordering
forall a. Maybe a
Nothing
precedes :: Ordering -> Ordering -> Bool
precedes = Ordering -> Ordering -> Bool
forall a. Ord a => a -> a -> Bool
(<)
enumDownFrom :: Ordering -> [Ordering]
enumDownFrom = Ordering -> [Ordering]
forall a. (DownwardEnum a, Enum a) => a -> [a]
preludeEnumDownFrom
enumDownFromTo :: Ordering -> Ordering -> [Ordering]
enumDownFromTo = Ordering -> Ordering -> [Ordering]
forall a. (DownwardEnum a, Enum a) => a -> a -> [a]
preludeEnumDownFromTo
{-# INLINE pred #-}
{-# INLINE precedes #-}
{-# INLINE enumDownFrom #-}
{-# INLINE enumDownFromTo #-}
instance Enum Ordering where
toEnum :: Int -> Maybe Ordering
toEnum Int
i
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
LT
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
EQ
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2 = Ordering -> Maybe Ordering
forall a. a -> Maybe a
Just Ordering
GT
| Bool
otherwise = Maybe Ordering
forall a. Maybe a
Nothing
fromEnum :: Ordering -> Maybe Int
fromEnum Ordering
LT = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
fromEnum Ordering
EQ = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1
fromEnum Ordering
GT = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2
enumFromThen :: Ordering -> Ordering -> [Ordering]
enumFromThen = Ordering -> Ordering -> [Ordering]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen
enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering]
enumFromThenTo = Ordering -> Ordering -> Ordering -> [Ordering]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo
{-# INLINE toEnum #-}
{-# INLINE fromEnum #-}
{-# INLINE enumFromThen #-}
{-# INLINE enumFromThenTo #-}
instance UpwardEnum Char where
#if __GLASGOW_HASKELL__ >= 708
succ :: Char -> Maybe Char
succ (C# Char#
c#)
| Int# -> Bool
isTrue# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
/=# Int#
0x10FFFF#)
= Char -> Maybe Char
forall a. a -> Maybe a
Just (Char -> Maybe Char) -> Char -> Maybe Char
forall a b. (a -> b) -> a -> b
$! Char# -> Char
C# (Int# -> Char#
chr# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
+# Int#
1#))
| Bool
otherwise = Maybe Char
forall a. Maybe a
Nothing
#elif defined __GLASGOW_HASKELL__
succ (C# c#)
| not (ord# c# ==# 0x10FFFF#) = Just $! C# (chr# (ord# c# +# 1#))
| otherwise = Nothing
#else
succ c
| not (ord c == 0x10FFFF) = Just $! chr (ord c + 1)
| otherwise = Nothing
#endif
succeeds :: Char -> Char -> Bool
succeeds = Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
(>)
enumFrom :: Char -> [Char]
enumFrom = Char -> [Char]
forall a. Enum a => a -> [a]
Prelude.enumFrom
enumFromTo :: Char -> Char -> [Char]
enumFromTo = Char -> Char -> [Char]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromTo
{-# INLINE succ #-}
{-# INLINE succeeds #-}
{-# INLINE enumFrom #-}
{-# INLINE enumFromTo #-}
instance DownwardEnum Char where
#if __GLASGOW_HASKELL__ >= 708
pred :: Char -> Maybe Char
pred (C# Char#
c#)
| Int# -> Bool
isTrue# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
/=# Int#
0#)
= Char -> Maybe Char
forall a. a -> Maybe a
Just (Char -> Maybe Char) -> Char -> Maybe Char
forall a b. (a -> b) -> a -> b
$! Char# -> Char
C# (Int# -> Char#
chr# (Char# -> Int#
ord# Char#
c# Int# -> Int# -> Int#
-# Int#
1#))
| Bool
otherwise = Maybe Char
forall a. Maybe a
Nothing
#elif defined __GLASGOW_HASKELL__
pred (C# c#)
| not (ord# c# ==# 0#) = Just $! C# (chr# (ord# c# -# 1#))
| otherwise = Nothing
#else
pred c
| not (ord c == 0) = Just $! chr (ord c - 1)
| otherwise = Nothing
#endif
precedes :: Char -> Char -> Bool
precedes = Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
(<)
enumDownFrom :: Char -> [Char]
enumDownFrom = Char -> [Char]
forall a. (DownwardEnum a, Enum a) => a -> [a]
preludeEnumDownFrom
enumDownFromTo :: Char -> Char -> [Char]
enumDownFromTo = Char -> Char -> [Char]
forall a. (DownwardEnum a, Enum a) => a -> a -> [a]
preludeEnumDownFromTo
{-# INLINE pred #-}
{-# INLINE precedes #-}
{-# INLINE enumDownFrom #-}
{-# INLINE enumDownFromTo #-}
instance Enum Char where
#if __GLASGOW_HASKELL__ >= 708
toEnum :: Int -> Maybe Char
toEnum (I# Int#
i#)
| Int# -> Bool
isTrue# (Int#
0# Int# -> Int# -> Int#
<=# Int#
i#)
Bool -> Bool -> Bool
&& Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
<=# Int#
0x10FFFF#) = Char -> Maybe Char
forall a. a -> Maybe a
Just (Char -> Maybe Char) -> Char -> Maybe Char
forall a b. (a -> b) -> a -> b
$! Char# -> Char
C# (Int# -> Char#
chr# Int#
i#)
| Bool
otherwise = Maybe Char
forall a. Maybe a
Nothing
fromEnum :: Char -> Maybe Int
fromEnum (C# Char#
c#)
| Int# -> Bool
isTrue# (Char# -> Char# -> Int#
leChar# (Int# -> Char#
chr# Int#
0#) Char#
c#)
Bool -> Bool -> Bool
&& Int# -> Bool
isTrue# (Char# -> Char# -> Int#
leChar# Char#
c# (Int# -> Char#
chr# Int#
0x10FFFF#)) = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int# -> Int
I# (Char# -> Int#
ord# Char#
c#)
| Bool
otherwise = Maybe Int
forall a. Maybe a
Nothing
#elif defined __GLASGOW_HASKELL__
toEnum (I# i#)
| 0# <=# i# && i# <=# 0x10FFFF# = Just $! C# (chr# i#)
| otherwise = Nothing
fromEnum (C# c#)
| leChar# (chr# 0#) c#
&& leChar# c# (chr# 0x10FFFF#) = Just $! I# (ord# c#)
| otherwise = Nothing
#else
toEnum i
| 0 <= i && i <= 0x10FFFF = Just $! chr i
| otherwise = Nothing
fromEnum c
| chr 0 <= c && c <= chr 0x10FFFF = Just $! ord c
| otherwise = Nothing
#endif
enumFromThen :: Char -> Char -> [Char]
enumFromThen = Char -> Char -> [Char]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen
enumFromThenTo :: Char -> Char -> Char -> [Char]
enumFromThenTo = Char -> Char -> Char -> [Char]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo
{-# INLINE toEnum #-}
{-# INLINE fromEnum #-}
{-# INLINE enumFromThen #-}
{-# INLINE enumFromThenTo #-}
instance UpwardEnum Int where
succ :: Int -> Maybe Int
succ Int
x
| Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
forall a. Bounded a => a
maxBound = Maybe Int
forall a. Maybe a
Nothing
| Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
succeeds :: Int -> Int -> Bool
succeeds = Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
(>)
enumFrom :: Int -> [Int]
enumFrom = Int -> [Int]
forall a. Enum a => a -> [a]
Prelude.enumFrom
enumFromTo :: Int -> Int -> [Int]
enumFromTo = Int -> Int -> [Int]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromTo
{-# INLINE succ #-}
{-# INLINE succeeds #-}
{-# INLINE enumFrom #-}
{-# INLINE enumFromTo #-}
instance DownwardEnum Int where
pred :: Int -> Maybe Int
pred Int
x
| Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
forall a. Bounded a => a
minBound = Maybe Int
forall a. Maybe a
Nothing
| Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
precedes :: Int -> Int -> Bool
precedes = Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
(<)
enumDownFrom :: Int -> [Int]
enumDownFrom = Int -> [Int]
forall a. (DownwardEnum a, Enum a) => a -> [a]
preludeEnumDownFrom
enumDownFromTo :: Int -> Int -> [Int]
enumDownFromTo = Int -> Int -> [Int]
forall a. (DownwardEnum a, Enum a) => a -> a -> [a]
preludeEnumDownFromTo
{-# INLINE pred #-}
{-# INLINE precedes #-}
{-# INLINE enumDownFrom #-}
{-# INLINE enumDownFromTo #-}
instance Enum Int where
toEnum :: Int -> Maybe Int
toEnum = Int -> Maybe Int
forall a. a -> Maybe a
Just
fromEnum :: Int -> Maybe Int
fromEnum = Int -> Maybe Int
forall a. a -> Maybe a
Just
enumFromThen :: Int -> Int -> [Int]
enumFromThen = Int -> Int -> [Int]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen
enumFromThenTo :: Int -> Int -> Int -> [Int]
enumFromThenTo = Int -> Int -> Int -> [Int]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo
{-# INLINE toEnum #-}
{-# INLINE fromEnum #-}
{-# INLINE enumFromThen #-}
{-# INLINE enumFromThenTo #-}
instance UpwardEnum Integer where
succ :: Integer -> Maybe Integer
succ Integer
n = Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> Integer -> Maybe Integer
forall a b. (a -> b) -> a -> b
$! Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1
succeeds :: Integer -> Integer -> Bool
succeeds = Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
(>)
enumFrom :: Integer -> [Integer]
enumFrom = Integer -> [Integer]
forall a. Enum a => a -> [a]
Prelude.enumFrom
enumFromTo :: Integer -> Integer -> [Integer]
enumFromTo = Integer -> Integer -> [Integer]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromTo
{-# INLINE succ #-}
{-# INLINE succeeds #-}
{-# INLINE enumFrom #-}
{-# INLINE enumFromTo #-}
instance DownwardEnum Integer where
pred :: Integer -> Maybe Integer
pred Integer
n = Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> Integer -> Maybe Integer
forall a b. (a -> b) -> a -> b
$! Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1
precedes :: Integer -> Integer -> Bool
precedes = Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
(<)
enumDownFrom :: Integer -> [Integer]
enumDownFrom = Integer -> [Integer]
forall a. (DownwardEnum a, Enum a) => a -> [a]
preludeEnumDownFrom
enumDownFromTo :: Integer -> Integer -> [Integer]
enumDownFromTo = Integer -> Integer -> [Integer]
forall a. (DownwardEnum a, Enum a) => a -> a -> [a]
preludeEnumDownFromTo
{-# INLINE pred #-}
{-# INLINE precedes #-}
{-# INLINE enumDownFrom #-}
{-# INLINE enumDownFromTo #-}
instance Enum Integer where
toEnum :: Int -> Maybe Integer
toEnum Int
n = Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> Integer -> Maybe Integer
forall a b. (a -> b) -> a -> b
$! Int -> Integer
forall a. Enum a => Int -> a
Prelude.toEnum Int
n
fromEnum :: Integer -> Maybe Int
fromEnum Integer
n
| Integer
min_ Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
n Bool -> Bool -> Bool
&& Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
max_ = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Integer -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Integer
n
| Bool
otherwise = Maybe Int
forall a. Maybe a
Nothing
where
min_ :: Integer
min_ = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
forall a. Bounded a => a
minBound :: Int)
max_ :: Integer
max_ = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
forall a. Bounded a => a
maxBound :: Int)
enumFromThen :: Integer -> Integer -> [Integer]
enumFromThen = Integer -> Integer -> [Integer]
forall a. Enum a => a -> a -> [a]
Prelude.enumFromThen
enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]
enumFromThenTo = Integer -> Integer -> Integer -> [Integer]
forall a. Enum a => a -> a -> a -> [a]
Prelude.enumFromThenTo
{-# INLINE toEnum #-}
{-# INLINE fromEnum #-}
{-# INLINE enumFromThen #-}
{-# INLINE enumFromThenTo #-}