content: 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
  
  asTypeOf :: a->a->a
  asTypeOf x = const x
  
  data Char
  data Integer
  data Int
  data Float
  data Double
  
  data IO a
  instance Functor IO
  instance Monad IO
  
  foreign import putStr :: String -> IO ()
  putStrLn s = putStr s >> putStr "\n"
  print x = putStrLn (show x)
  
  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 () = () deriving (Eq,Ord,Show)
  data (,) a b = (,) a b deriving (Eq,Ord,Show)
  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  (,,,,,,,) a b c d e f g h =  (,,,,,,,) a b c d e f g h
  
  
  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
  
  infixl 1 >>, >>=
  
  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
  
    fail = error
    m1>>m2 = m1>>=const m2
  
  sequence :: Monad m => [m a] -> m [a]
  sequence
      = foldr mcons (return [])
    where
        mcons p q
  	  = p >>= (\ x -> q >>= (\ y -> return (x : y)))
   
  mapM :: Monad m => (a -> m b) -> [a] -> m [b]
  mapM f as = sequence (map f as)
  
  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
  
    x-y=x+negate y
    negate x = 0-x
  
  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
  
  --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
  -}
  --------------------------------------------------------------------------------
  foreign import primIntegerEq :: Integer -> Integer -> Bool
  foreign import primIntegerLte :: Integer -> Integer -> Bool
  foreign import primIntegerAdd :: Integer -> Integer -> Integer
  foreign import primIntegerNegate :: Integer -> Integer
  foreign import primIntegerSignum :: Integer -> Integer
  foreign import primIntegerAbs :: Integer -> Integer
  
  instance Eq Integer where (==) = primIntegerEq
  
  instance Ord Integer where (<=) = primIntegerLte
  instance Num Integer where
    (+) = primIntegerAdd
    fromInteger = id
    negate = primIntegerNegate
    abs = primIntegerAbs
    signum = primIntegerSignum
  
  instance Show Integer where show=undefined
  instance Enum Integer
  
  --------------------------------------------------------------------------------
  foreign import primIntEq :: Int -> Int -> Bool
  foreign import primInteger2Int :: Integer -> Int
  foreign import primIntAdd :: Int -> Int -> Int
  foreign import primIntNegate :: Int -> Int
  foreign import primIntSignum :: Int -> Int
  foreign import primIntAbs :: Int -> Int
  
  instance Eq Int where (==) = primIntEq
  
  instance Ord Int
  instance Show Int
  
  instance Num Int where
    (+) = primIntAdd
    negate = primIntNegate
    abs = primIntAbs
    signum = primIntSignum
    fromInteger = primInteger2Int
  
  --------------------------------------------------------------------------------
  
  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 Fractional Float
  instance Fractional Double
  
  --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  (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 where
    toInteger = id
    quotRem n d = error "quotRem not implemented yet"
  
  instance Integral Int
  instance Real Integer
  instance Real Int
  --instance Real Double
  --instance Floating Double
  --instance RealFrac Double
  