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