%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRAP/AQUA Project, Glasgow University, 1992-1996
%
\section[PrelBase]{Module @PrelBase@}
\begin{code}
{-# OPTIONS -fno-implicit-prelude #-}
-module PrelBase(
+module PrelBase
+ (
module PrelBase,
module PrelGHC -- Re-export PrelGHC, to avoid lots of people
-- having to import it explicitly
- ) where
+ )
+ where
import {-# SOURCE #-} PrelErr ( error )
import PrelGHC
\end{code}
-\begin{code}
-{-
-class Eval a
-data Bool = False | True
-data Int = I# Int#
-data Double = D# Double#
-data () = () --easier to do explicitly: deriving (Eq, Ord, Enum, Show, Bounded)
- -- (avoids weird-named functions, e.g., con2tag_()#
-
-data Maybe a = Nothing | Just a
-data Ordering = LT | EQ | GT deriving( Eq )
-
-type String = [Char]
-
-data Char = C# Char#
-data [] a = [] | a : [a] -- do explicitly: deriving (Eq, Ord)
- -- to avoid weird names like con2tag_[]#
-
-
--------------- Stage 2 -----------------------
-not True = False
-not False = True
-True && x = x
-False && x = False
-otherwise = True
-
-maybe :: b -> (a -> b) -> Maybe a -> b
-maybe n f Nothing = n
-maybe n f (Just x) = f x
-
--------------- Stage 3 -----------------------
-class Eq a where
- (==), (/=) :: a -> a -> Bool
-
- x /= y = not (x == y)
-
--- f :: Eq a => a -> a -> Bool
-f x y = x == y
-
-g :: Eq a => a -> a -> Bool
-g x y = f x y
-
--------------- Stage 4 -----------------------
-
-class (Eq a) => Ord a where
- compare :: a -> a -> Ordering
- (<), (<=), (>=), (>):: a -> a -> Bool
- max, min :: a -> a -> a
-
--- An instance of Ord should define either compare or <=
--- Using compare can be more efficient for complex types.
- compare x y
- | x == y = EQ
- | x <= y = LT
- | otherwise = GT
-
- x <= y = compare x y /= GT
- x < y = compare x y == LT
- x >= y = compare x y /= LT
- x > y = compare x y == GT
- max x y = case (compare x y) of { LT -> y ; EQ -> x ; GT -> x }
- min x y = case (compare x y) of { LT -> x ; EQ -> x ; GT -> y }
-
-eqInt (I# x) (I# y) = x ==# y
-
-instance Eq Int where
- (==) x y = x `eqInt` y
-
-instance Ord Int where
- compare x y = error "help"
-
-class Bounded a where
- minBound, maxBound :: a
-
-
-type ShowS = String -> String
-
-class Show a where
- showsPrec :: Bool -> a -> ShowS
- showList :: [a] -> ShowS
-
- showList ls = showList__ (showsPrec True) ls
-
-showList__ :: (a -> ShowS) -> [a] -> ShowS
-showList__ showx [] = showString "[]"
-
-showString :: String -> ShowS
-showString = (++)
-
-[] ++ [] = []
-
-shows :: (Show a) => a -> ShowS
-shows = showsPrec True
-
--- show :: (Show a) => a -> String
---show x = shows x ""
--}
-\end{code}
-
-
%*********************************************************
%* *
-\subsection{Standard classes @Eq@, @Ord@, @Bounded@, @Eval@}
+\subsection{Standard classes @Eq@, @Ord@, @Bounded@
%* *
%*********************************************************
(==), (/=) :: a -> a -> Bool
x /= y = not (x == y)
+ x == y = not (x /= y)
class (Eq a) => Ord a where
compare :: a -> a -> Ordering
class Bounded a where
minBound, maxBound :: a
-
-class Eval a
\end{code}
%*********************************************************
%* *
-\subsection{Monadic classes @Functor@, @Monad@, @MonadZero@, @MonadPlus@}
+\subsection{Monadic classes @Functor@, @Monad@ }
%* *
%*********************************************************
\begin{code}
class Functor f where
- map :: (a -> b) -> f a -> f b
+ fmap :: (a -> b) -> f a -> f b
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
return :: a -> m a
+ fail :: String -> m a
m >> k = m >>= \_ -> k
+ fail s = error s
-class (Monad m) => MonadZero m where
- zero :: m a
-
-class (MonadZero m) => MonadPlus m where
- (++) :: m a -> m a -> m a
\end{code}
\begin{code}
class Enum a where
+ succ, pred :: a -> a
toEnum :: Int -> a
fromEnum :: a -> Int
enumFrom :: a -> [a] -- [n..]
enumFromTo :: a -> a -> [a] -- [n..m]
enumFromThenTo :: a -> a -> a -> [a] -- [n,n'..m]
+ succ = toEnum . (+1) . fromEnum
+ pred = toEnum . (+(-1)) . fromEnum
enumFromTo n m = map toEnum [fromEnum n .. fromEnum m]
enumFromThenTo n n' m
= map toEnum [fromEnum n, fromEnum n' .. fromEnum m]
-class (Eq a, Show a, Eval a) => Num a where
+class (Eq a, Show a) => Num a where
(+), (-), (*) :: a -> a -> a
negate :: a -> a
abs, signum :: a -> a
fromInteger :: Integer -> a
fromInt :: Int -> a -- partain: Glasgow extension
- x - y = x + negate y
- fromInt (I# i#) = fromInteger (int2Integer# i#)
+ x - y = x + negate y
+ negate x = 0 - x
+ fromInt (I# i#) = fromInteger (case int2Integer# i# of
+ (# a, s, d #) -> J# a s d)
-- Go via the standard class-op if the
-- non-standard one ain't provided
\end{code}
\begin{code}
-succ, pred :: Enum a => a -> a
-succ = toEnum . (+1) . fromEnum
-pred = toEnum . (subtract 1) . fromEnum
-
-chr = (toEnum :: Int -> Char)
-ord = (fromEnum :: Char -> Int)
+chr :: Int -> Char
+chr = toEnum
+ord :: Char -> Int
+ord = fromEnum
ord_0 :: Num a => a
ord_0 = fromInt (ord '0')
-{-# GENERATE_SPECS subtract a{Int} #-}
+{-# SPECIALISE subtract :: Int -> Int -> Int #-}
subtract :: (Num a) => a -> a -> a
subtract x y = y - x
\end{code}
class Show a where
showsPrec :: Int -> a -> ShowS
+ show :: a -> String
showList :: [a] -> ShowS
- showList ls = showList__ (showsPrec 0) ls
+ showList ls = showList__ (showsPrec 0) ls
+ showsPrec _ x s = show x ++ s
+ show x = showsPrec 0 x ""
\end{code}
%*********************************************************
data [] a = [] | a : [a] -- do explicitly: deriving (Eq, Ord)
-- to avoid weird names like con2tag_[]#
+
+
instance (Eq a) => Eq [a] where
[] == [] = True
(x:xs) == (y:ys) = x == y && xs == ys
- xs == ys = False
+ _xs == _ys = False
+
xs /= ys = if (xs == ys) then False else True
instance (Ord a) => Ord [a] where
min a b = case compare a b of { LT -> a; EQ -> a; GT -> b }
compare [] [] = EQ
- compare (x:xs) [] = GT
- compare [] (y:ys) = LT
+ compare (_:_) [] = GT
+ compare [] (_:_) = LT
compare (x:xs) (y:ys) = case compare x y of
LT -> LT
GT -> GT
EQ -> compare xs ys
+map :: (a -> b) -> [a] -> [b]
+map _ [] = []
+map f (x:xs) = f x : map f xs
+
+(++) :: [a] -> [a] -> [a]
+[] ++ ys = ys
+(x:xs) ++ ys = x : (xs ++ ys)
+
instance Functor [] where
- map f [] = []
- map f (x:xs) = f x : map f xs
+ fmap = map
instance Monad [] where
m >>= k = foldr ((++) . k) [] m
m >> k = foldr ((++) . (\ _ -> k)) [] m
return x = [x]
-
-instance MonadZero [] where
- zero = []
-
-instance MonadPlus [] where
-#ifdef USE_REPORT_PRELUDE
- xs ++ ys = foldr (:) ys xs
-#else
- [] ++ ys = ys
- (x:xs) ++ ys = x : (xs ++ ys)
-#endif
+ fail _ = []
instance (Show a) => Show [a] where
- showsPrec p = showList
+ showsPrec _ = showList
showList ls = showList__ (showsPrec 0) ls
\end{code}
\begin{code}
foldr :: (a -> b -> b) -> b -> [a] -> b
-foldr f z [] = z
+foldr _ z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
-- takeWhile, applied to a predicate p and a list xs, returns the longest
-- (takeWhile p xs, dropWhile p xs), while break p uses the negation of p.
takeWhile :: (a -> Bool) -> [a] -> [a]
-takeWhile p [] = []
+takeWhile _ [] = []
takeWhile p (x:xs)
| p x = x : takeWhile p xs
| otherwise = []
dropWhile :: (a -> Bool) -> [a] -> [a]
-dropWhile p [] = []
+dropWhile _ [] = []
dropWhile p xs@(x:xs')
| p x = dropWhile p xs'
| otherwise = xs
#ifdef USE_REPORT_PRELUDE
(x:_) !! 0 = x
(_:xs) !! n | n > 0 = xs !! (n-1)
-(_:_) !! _ = error "PreludeList.!!: negative index"
-[] !! _ = error "PreludeList.!!: index too large"
+(_:_) !! _ = error "Prelude.(!!): negative index"
+[] !! _ = error "Prelude.(!!): index too large"
#else
-- HBC version (stolen), then unboxified
-- The semantics is not quite the same for error conditions
-- in the more efficient version.
--
-_ !! n | n < 0 = error "(!!){PreludeList}: negative index\n"
+_ !! n | n < 0 = error "Prelude.(!!): negative index\n"
xs !! n = sub xs (case n of { I# n# -> n# })
where sub :: [a] -> Int# -> a
- sub [] _ = error "(!!){PreludeList}: index too large\n"
- sub (x:xs) n# = if n# ==# 0#
- then x
- else sub xs (n# -# 1#)
+ sub [] _ = error "Prelude.(!!): index too large\n"
+ sub (y:ys) n# = if n# ==# 0#
+ then y
+ else sub ys (n# -# 1#)
#endif
\end{code}
%*********************************************************
%* *
-\subsection{Type @Void@}
-%* *
-%*********************************************************
-
-The type @Void@ is built in, but it needs a @Show@ instance.
-
-\begin{code}
-void :: Void
-void = error "You tried to evaluate void"
-
-instance Show Void where
- showsPrec p f = showString "<<void>>"
- showList ls = showList__ (showsPrec 0) ls
-\end{code}
-
-
-%*********************************************************
-%* *
\subsection{Type @Bool@}
%* *
%*********************************************************
(&&), (||) :: Bool -> Bool -> Bool
True && x = x
-False && x = False
-True || x = True
+False && _ = False
+True || _ = True
False || x = x
not :: Bool -> Bool
compare () () = EQ
instance Enum () where
+ succ x = error "Prelude.Enum.succ{()}: not possible"
+ pred x = error "Prelude.Enum.pred{()}: not possible"
toEnum 0 = ()
- toEnum _ = error "Prelude.Enum.().toEnum: argument not 0"
+ toEnum _ = error "Prelude.Enum.toEnum{()}: argument not 0"
fromEnum () = 0
enumFrom () = [()]
enumFromThen () () = [()]
enumFromThenTo () () () = [()]
instance Show () where
- showsPrec p () = showString "()"
+ showsPrec _ () = showString "()"
showList ls = showList__ (showsPrec 0) ls
\end{code}
%*********************************************************
\begin{code}
-data Ordering = LT | EQ | GT deriving (Eq, Ord, Enum, Bounded, Show {- Read -})
+data Ordering = LT | EQ | GT deriving (Eq, Ord, Enum, Bounded, Show {- in PrelRead: Read -})
\end{code}
data Char = C# Char# deriving (Eq, Ord)
instance Enum Char where
+ succ c@(C# c#)
+ | not (ord# c# ==# 255#) = C# (chr# (ord# c# +# 1#))
+ | otherwise = error ("Prelude.Enum.succ{Char}: tried to take `succ' of maxBound")
+ pred c@(C# c#)
+ | not (ord# c# ==# 0#) = C# (chr# (ord# c# -# 1#))
+ | otherwise = error ("Prelude.Enum.pred{Char}: tried to to take `pred' of minBound")
+
toEnum (I# i) | i >=# 0# && i <=# 255# = C# (chr# i)
- | otherwise = error ("Prelude.Enum.Char.toEnum:out of range: " ++ show (I# i))
- fromEnum (C# c) = I# (ord# c)
+ | otherwise = error ("Prelude.Enum.toEnum{Char}: out of range: " ++ show (I# i))
+ fromEnum (C# c) = I# (ord# c)
- enumFrom (C# c) = efttCh (ord# c) 1# (># 255#)
- enumFromTo (C# c1) (C# c2) = efttCh (ord# c1) 1# (># (ord# c2))
+ enumFrom (C# c) = efttCh (ord# c) 1# (># 255#)
+ enumFromTo (C# c1) (C# c2)
+ | c1 `leChar#` c2 = efttCh (ord# c1) 1# (># (ord# c2))
+ | otherwise = []
enumFromThen (C# c1) (C# c2)
| c1 `leChar#` c2 = efttCh (ord# c1) (ord# c2 -# ord# c1) (># 255#)
| otherwise = efttCh (ord# c1) (ord# c2 -# ord# c1) (<# (ord# c3))
efttCh :: Int# -> Int# -> (Int# -> Bool) -> [Char]
-efttCh now step done
- = go now
+efttCh init step done
+ = go init
where
go now | done now = []
| otherwise = C# (chr# now) : go (now +# step)
instance Show Char where
- showsPrec p '\'' = showString "'\\''"
- showsPrec p c = showChar '\'' . showLitChar c . showChar '\''
+ showsPrec _ '\'' = showString "'\\''"
+ showsPrec _ c = showChar '\'' . showLitChar c . showChar '\''
showList cs = showChar '"' . showl cs
where showl "" = showChar '"'
- showl ('"':cs) = showString "\\\"" . showl cs
- showl (c:cs) = showLitChar c . showl cs
+ showl ('"':xs) = showString "\\\"" . showl xs
+ showl (x:xs) = showLitChar x . showl xs
\end{code}
\begin{code}
isAscii, isLatin1, isControl, isPrint, isSpace, isUpper,
- isLower, isAlpha, isDigit, isOctDigit, isHexDigit, isAlphanum :: Char -> Bool
-isAscii c = fromEnum c < 128
+ isLower, isAlpha, isDigit, isOctDigit, isHexDigit, isAlphaNum :: Char -> Bool
+isAscii c = c < '\x80'
isLatin1 c = c <= '\xff'
isControl c = c < ' ' || c >= '\DEL' && c <= '\x9f'
isPrint c = not (isControl c)
isLower c = c >= 'a' && c <= 'z' ||
c >= '\xDF' && c <= '\xF6' ||
c >= '\xF8' && c <= '\xFF'
+isAsciiLower c = c >= 'a' && c <= 'z'
+isAsciiUpper c = c >= 'A' && c <= 'Z'
+
isAlpha c = isLower c || isUpper c
isDigit c = c >= '0' && c <= '9'
isOctDigit c = c >= '0' && c <= '7'
isHexDigit c = isDigit c || c >= 'A' && c <= 'F' ||
c >= 'a' && c <= 'f'
-isAlphanum c = isAlpha c || isDigit c
+isAlphaNum c = isAlpha c || isDigit c
-- Case-changing operations
toUpper, toLower :: Char -> Char
-toUpper c | isLower c && c /= '\xDF' && c /= '\xFF'
- = toEnum (fromEnum c - fromEnum 'a' + fromEnum 'A')
- | otherwise = c
+toUpper c@(C# c#)
+ | isAsciiLower c = C# (chr# (ord# c# -# 32#))
+ | isAscii c = c
+ -- fall-through to the slower stuff.
+ | isLower c && c /= '\xDF' && c /= '\xFF'
+ = toEnum (fromEnum c - fromEnum 'a' + fromEnum 'A')
+ | otherwise
+ = c
-toLower c | isUpper c = toEnum (fromEnum c - fromEnum 'A'
+
+
+toLower c@(C# c#)
+ | isAsciiUpper c = C# (chr# (ord# c# +# 32#))
+ | isAscii c = c
+ | isUpper c = toEnum (fromEnum c - fromEnum 'A'
+ fromEnum 'a')
- | otherwise = c
+ | otherwise = c
+asciiTab :: [String]
asciiTab = -- Using an array drags in the array module. listArray ('\NUL', ' ')
["NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
"BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
max x y = case (compareInt x y) of { LT -> y ; EQ -> x ; GT -> x }
min x y = case (compareInt x y) of { LT -> x ; EQ -> x ; GT -> y }
+compareInt :: Int -> Int -> Ordering
(I# x) `compareInt` (I# y) | x <# y = LT
| x ==# y = EQ
| otherwise = GT
+instance Bounded Int where
+ minBound = -2147483648 -- GHC <= 2.09 had this at -2147483647
+ maxBound = 2147483647
+
instance Enum Int where
+ succ x
+ | x == maxBound = error "Prelude.Enum.succ{Int}: tried to take `succ' of maxBound"
+ | otherwise = x+1
+ pred x
+ | x == minBound = error "Prelude.Enum.pred{Int}: tried to take `pred' of minBound"
+ | otherwise = x-1
+
toEnum x = x
fromEnum x = x
#ifndef USE_FOLDR_BUILD
- enumFrom (I# c) = eftInt c 1#
- enumFromTo (I# c1) (I# c2) = efttInt c1 1# (># c2)
- enumFromThen (I# c1) (I# c2) = eftInt c1 (c2 -# c1)
+ enumFrom (I# c) = efttInt True c 1# (\ _ -> False)
+
+ enumFromTo (I# c1) (I# c2)
+ | c1 <=# c2 = efttInt True c1 1# (># c2)
+ | otherwise = []
+
+ enumFromThen (I# c1) (I# c2)
+ | c1 <# c2 = efttInt True c1 (c2 -# c1) (\ _ -> False)
+ | otherwise = efttInt False c1 (c2 -# c1) (\ _ -> False)
enumFromThenTo (I# c1) (I# c2) (I# c3)
- | c1 <=# c2 = efttInt c1 (c2 -# c1) (># c3)
- | otherwise = efttInt c1 (c2 -# c1) (<# c3)
+ | c1 <=# c2 = efttInt True c1 (c2 -# c1) (># c3)
+ | otherwise = efttInt False c1 (c2 -# c1) (<# c3)
#else
{-# INLINE enumFrom #-}
let g x = if x <= y then x `c` g (x `plusInt` 1) else n in g x)
#endif
-efttInt :: Int# -> Int# -> (Int# -> Bool) -> [Int]
-efttInt now step done
- = go now
- where
- go now | done now = []
- | otherwise = I# now : go (now +# step)
-
-eftInt :: Int# -> Int# -> [Int]
-eftInt now step
- = go now
+efttInt :: Bool -> Int# -> Int# -> (Int# -> Bool) -> [Int]
+efttInt increasing init step done = go init
where
- go now = I# now : go (now +# step)
-
+ go now
+ | done now = []
+ | increasing && now ># nxt = [I# now] -- overflowed
+ | not increasing && now <# nxt = [I# now] -- underflowed
+ | otherwise = I# now : go nxt
+ where
+ nxt = now +# step
instance Num Int where
(+) x y = plusInt x y
%* *
%*********************************************************
-Just the type declarations. If we don't actually use any @Integers@ we'd
-rather not link the @Integer@ module at all; and the default-decl stuff
-in the renamer tends to slurp in @Double@ regardless.
-
\begin{code}
data Float = F# Float#
data Double = D# Double#
data Integer = J# Int# Int# ByteArray#
-\end{code}
+instance Eq Integer where
+ (J# a1 s1 d1) == (J# a2 s2 d2)
+ = (cmpInteger# a1 s1 d1 a2 s2 d2) ==# 0#
+
+ (J# a1 s1 d1) /= (J# a2 s2 d2)
+ = (cmpInteger# a1 s1 d1 a2 s2 d2) /=# 0#
+
+\end{code}
%*********************************************************
%* *
%*********************************************************
\begin{code}
-instance Eval (a -> b)
-
instance Show (a -> b) where
- showsPrec p f = showString "<<function>>"
+ showsPrec _ _ = showString "<<function>>"
showList ls = showList__ (showsPrec 0) ls
-- function composition
{-# INLINE (.) #-}
-{- GENERATE_SPECS (.) a b c -}
(.) :: (b -> c) -> (a -> b) -> a -> c
(.) f g x = f (g x)
asTypeOf = const
\end{code}
-
-%*********************************************************
-%* *
-\subsection{Miscellaneous}
-%* *
-%*********************************************************
-
-
-\begin{code}
-data Lift a = Lift a
-{- GENERATE_SPECS data a :: Lift a -}
-\end{code}
-
-
-
-
%*********************************************************
%* *
\subsection{Support code for @Show@}
shows :: (Show a) => a -> ShowS
shows = showsPrec 0
-show :: (Show a) => a -> String
-show x = shows x ""
-
showChar :: Char -> ShowS
showChar = (:)
showParen :: Bool -> ShowS -> ShowS
showParen b p = if b then showChar '(' . p . showChar ')' else p
-{- GENERATE_SPECS showList__ a -}
showList__ :: (a -> ShowS) -> [a] -> ShowS
-showList__ showx [] = showString "[]"
+showList__ _ [] = showString "[]"
showList__ showx (x:xs) = showChar '[' . showx x . showl xs
where
showl [] = showChar ']'
- showl (x:xs) = showChar ',' . showx x . showl xs
+ showl (y:ys) = showChar ',' . showx y . showl ys
showSpace :: ShowS
showSpace = {-showChar ' '-} \ xs -> ' ' : xs
showLitChar '\SO' = protectEsc (== 'H') (showString "\\SO")
showLitChar c = showString ('\\' : asciiTab!!ord c)
+protectEsc :: (Char -> Bool) -> ShowS -> ShowS
protectEsc p f = f . cont
where cont s@(c:_) | p c = "\\&" ++ s
cont s = s
intToDigit :: Int -> Char
intToDigit i
| i >= 0 && i <= 9 = toEnum (fromEnum '0' + i)
- | i >= 10 && i <= 15 = toEnum (fromEnum 'a' + i -10)
- | otherwise = error ("Char.intToDigit: not a digit" ++ show i)
+ | i >= 10 && i <= 15 = toEnum (fromEnum 'a' + i - 10)
+ | otherwise = error ("Char.intToDigit: not a digit " ++ show i)
\end{code}
\begin{code}
showSignedInt :: Int -> Int -> ShowS
showSignedInt p (I# n) r
- = -- from HBC version; support code follows
- if n <# 0# && p > 6 then '(':itos n++(')':r) else itos n ++ r
-
-itos :: Int# -> String
-itos n =
- if n <# 0# then
- if negateInt# n <# 0# then
- -- n is minInt, a difficult number
- itos (n `quotInt#` 10#) ++ itos' (negateInt# (n `remInt#` 10#)) []
- else
- '-':itos' (negateInt# n) []
- else
- itos' n []
- where
- itos' :: Int# -> String -> String
- itos' n cs =
- if n <# 10# then
- C# (chr# (n +# ord# '0'#)) : cs
- else
- itos' (n `quotInt#` 10#) (C# (chr# (n `remInt#` 10# +# ord# '0'#)) : cs)
+ | n <# 0# && p > 6 = '(':itos n (')':r)
+ | otherwise = itos n r
+
+itos :: Int# -> String -> String
+itos n r
+ | n >=# 0# = itos' n r
+ | negateInt# n <# 0# = -- n is minInt, a difficult number
+ itos (n `quotInt#` 10#) (itos' (negateInt# (n `remInt#` 10#)) r)
+ | otherwise = '-':itos' (negateInt# n) r
+ where
+ itos' :: Int# -> String -> String
+ itos' x cs
+ | x <# 10# = C# (chr# (x +# ord# '0'#)) : cs
+ | otherwise = itos' (x `quotInt#` 10#)
+ (C# (chr# (x `remInt#` 10# +# ord# '0'#)) : cs)
\end{code}
%*********************************************************
{-# INLINE eqInt #-}
{-# INLINE neInt #-}
+plusInt, minusInt, timesInt, quotInt, remInt :: Int -> Int -> Int
plusInt (I# x) (I# y) = I# (x +# y)
minusInt(I# x) (I# y) = I# (x -# y)
timesInt(I# x) (I# y) = I# (x *# y)
quotInt (I# x) (I# y) = I# (quotInt# x y)
remInt (I# x) (I# y) = I# (remInt# x y)
+
+negateInt :: Int -> Int
negateInt (I# x) = I# (negateInt# x)
+
+gtInt, geInt, eqInt, neInt, ltInt, leInt :: Int -> Int -> Bool
gtInt (I# x) (I# y) = x ># y
geInt (I# x) (I# y) = x >=# y
eqInt (I# x) (I# y) = x ==# y
ltInt (I# x) (I# y) = x <# y
leInt (I# x) (I# y) = x <=# y
\end{code}
+
+Convenient boxed Integer PrimOps. These are 'thin-air' Ids, so
+it's nice to have them in PrelBase.
+
+\begin{code}
+{-# INLINE int2Integer #-}
+{-# INLINE addr2Integer #-}
+int2Integer :: Int# -> Integer
+int2Integer i = case int2Integer# i of (# a, s, d #) -> J# a s d
+addr2Integer :: Addr# -> Integer
+addr2Integer x = case addr2Integer# x of (# a, s, d #) -> J# a s d
+
+integer_0, integer_1, integer_2, integer_m1 :: Integer
+integer_0 = int2Integer 0#
+integer_1 = int2Integer 1#
+integer_2 = int2Integer 2#
+integer_m1 = int2Integer (negateInt# 1#)
+\end{code}
projects / ghc-hetmet.git / blobdiff