Prelude.hs
Plain text version of Prelude.hs
module Prelude(module Prelude,module PreludeText,module PreludeList) where
import PreludeText
import PreludeList
infixr 5 :
infixr 0 $
infixr 9 .
-- For the P-Logic extension:
data Prop
--type Pred a = a->Prop
(f . g) x = f (g x)
id x = x
const x y = x
flip f x y = f y x
f $ x = f x
data Char
data Integer
data Int
data Float
data Double
foreign import primSeq :: a -> b -> b
seq = primSeq
foreign import primError :: String -> a
error = primError
undefined = error "undefined"
type String = [Char]
data [] a = [] | a : [a] deriving (Eq,Ord)
data () = ()
data (,) a b = (,) a b
data (,,) a b c = (,,) a b c
data (,,,) a b c d = (,,,) a b c d
data (,,,,) a b c d e = (,,,,) a b c d e
data (,,,,,) a b c d e f = (,,,,,) a b c d e f
data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g
data Bool = False | True deriving (Eq,Ord,Bounded,Show)
data Maybe a = Nothing | Just a deriving (Eq,Ord)
data Either a b = Left a | Right b deriving (Eq)
not b = if b then False else True
class Functor f where
fmap :: (a->b)->f a->f b
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
fail :: String -> m a
m1>>m2 = m1>>=const m2
instance Functor Maybe where
fmap g m = case m of
Nothing -> Nothing
Just x -> Just (g x)
instance Monad Maybe where
Just x >>= f = f x
Nothing >>= _ = Nothing
return x = Just x
fail _ = Nothing
m1>>m2 =m1>>=const m2
instance Functor [] where fmap = map
maybe n j Nothing = n
maybe n j (Just x) = j x
class (Eq a,Show a) => Num a where
(+),(-),(*) :: a -> a -> a
negate :: a -> a
abs, signum :: a -> a
fromInteger :: Integer -> a
--even, odd :: (Integral a) => a -> Bool
even n = n `rem` 2 == 0
odd n = not (even n)
infixl 6 +
fst (x,y) = x
snd (x,y) = y
infix 4 ==,/=,<,<=,>=,>
class Eq a where
(==),(/=) :: a -> a -> Bool
x/=y = not (x==y)
x==y = not (x/=y)
class Eq a => Ord a where
compare :: a -> a -> Ordering
(<=) :: a -> a -> Bool
min,max :: a -> a -> a
min x y = if x <= y then x else y
max x y = if x <= y then y else x
x<=y = case compare x y of
LT -> True
EQ -> True
GT -> False
data Ordering = LT | EQ | GT deriving (Eq,Ord)
x>y = not (x<=y)
x>=y = y<=x
x<y = not (x>=y)
lexOrder EQ o = o
lexOrder o _ = o
class Bounded a where minBound,maxBound :: a
class Enum a where
succ,pred :: a
toEnum :: Int -> a
fromEnum :: a -> Int
enumFrom :: a -> [a]
enumFromThen :: a -> a -> [a]
enumFromTo :: a -> a -> [a]
enumFromThenTo :: a -> a -> a -> [a]
otherwise = True
curry f x y = f (x,y)
uncurry f (x,y) = f x y
{-
eqList :: Eq a => [a]->[a]->Bool
[] `eqList` [] = True
(x:xs) `eqList` (y:ys) = (x==y) && (xs `eqList` ys)
_ `eqList` _ = False
--}
{-
instance Eq a => Eq [a] where
--(==) = eqLista
[] == [] = True
(x:xs) == (y:ys) = (x==y) && (xs == ys)
_ == _ = False
-}
instance Num Integer
instance Eq Integer
instance Ord Integer
instance Show Integer
instance Enum Integer
instance Eq Int
instance Ord Int
instance Show Int
instance Num Int
instance Eq Char
instance Num Float
instance Show Float
instance Eq Float
instance Show Double
instance Num Double
instance Ord Double
instance Eq Double
instance Enum Int
instance (Eq a,Eq b) => Eq (a,b) where
(a1,b1) == (a2,b2) = a1==a2 && b1==b2
infixr 3 &&
True && b = b
_ && _ = False
infixr 2 ||
False || b = b
_ || _ = True
------
data (Integral a) => Ratio a = !a :% !a deriving (Eq)
type Rational = Ratio Integer
class (Real a, Enum a) => Integral a where
quot, rem :: a -> a -> a
div, mod :: a -> a -> a
quotRem, divMod :: a -> a -> (a,a)
toInteger :: a -> Integer
-- Minimal complete definition:
-- quotRem, toInteger
n `quot` d = q where (q,r) = quotRem n d
n `rem` d = r where (q,r) = quotRem n d
n `div` d = q where (q,r) = divMod n d
n `mod` d = r where (q,r) = divMod n d
divMod n d = if signum r == - signum d then (q-1, r+d) else qr
where qr@(q,r) = quotRem n d
class (Num a, Ord a) => Real a where
toRational :: a -> Rational
{-
class (Num a) => Fractional a where
(/) :: a -> a -> a
recip :: a -> a
fromRational :: Rational -> a
-- Minimal complete definition:
-- fromRational and (recip or (/))
recip x = 1 / x
x / y = x * recip y
class (Real a, Fractional a) => RealFrac a where
properFraction :: (Integral b) => a -> (b,a)
truncate, round :: (Integral b) => a -> b
ceiling, floor :: (Integral b) => a -> b
-- Minimal complete definition:
-- properFraction
truncate x = m where (m,_) = properFraction x
round x = let (n,r) = properFraction x
m = if r < 0 then n - 1 else n + 1
in case signum (abs r - 0.5) of
-1 -> n
0 -> if even n then n else m
1 -> m
ceiling x = if r > 0 then n + 1 else n
where (n,r) = properFraction x
floor x = if r < 0 then n - 1 else n
where (n,r) = properFraction x
class (Fractional a) => Floating a where
pi :: a
exp, log, sqrt :: a -> a
(**), logBase :: a -> a -> a
sin, cos, tan :: a -> a
asin, acos, atan :: a -> a
sinh, cosh, tanh :: a -> a
asinh, acosh, atanh :: a -> a
-- Minimal complete definition:
-- pi, exp, log, sin, cos, sinh, cosh
-- asin, acos, atan
-- asinh, acosh, atanh
x ** y = exp (log x * y)
logBase x y = log y / log x
sqrt x = x ** 0.5
tan x = sin x / cos x
tanh x = sinh x / cosh x
-}
fromIntegral :: (Integral a, Num b) => a -> b
fromIntegral = fromInteger . toInteger
instance Integral Integer
instance Integral Int
instance Real Integer
instance Real Int
instance Real Double
--instance Fractional Double
--instance Floating Double
--instance RealFrac Double
Valid HTML?