module TestPrelude1  where

infix  6  &&



----------------- BOOLEANS 
data Bool = True | False
otherwise = True

not True =  False 
not False = True

True  && b = b
False && _ = False

instance Eq Bool where 
   True  == True  = True
   False == False = True
   _     == _     = False


instance Bounded Bool where
   minBound = True
   maxBound = False




------------------------------
class Eq a where
    (==), (/=) :: a -> a -> Bool

    -- Minimal complete definition: (==) or (/=)
    x == y      = not (x/=y)
    x /= y      = not (x==y)



-------------------------- ORDERING
data Ordering  = EQ | LT | GT 
instance Eq Ordering  where
   EQ == EQ = True
   LT == LT = True
   GT == GT = True
   _  == _  = False

---------------------------------------


---------------------------------------- Ints
data Int
primitive primIntEq      :: Int -> Int -> Bool
primitive intPrimBinop   :: Int -> Int -> Int
primitive primCompareInt :: Int -> Int -> Ordering

instance Eq Int where
    i1 == i2 = primIntEq i1 i2

instance Num Int where
     x + y = intPrimBinop x y 
     x * y = intPrimBinop x y
     abs x    = x
     signum x = x
instance Ord Int where
   compare x y = primCompareInt x y 
------------------------------------------



------------------------------------------- Integers
data Integer

primitive primIntegerEq      :: Integer -> Integer -> Bool
primitive integerPrimBinop   :: Integer -> Integer -> Integer
primitive primCompareInteger :: Integer -> Integer -> Ordering

instance Eq Integer where
    i1 == i2 = primIntegerEq i1 i2


instance Num Integer where
     x + y = integerPrimBinop x y 
     x * y = integerPrimBinop x y
     abs x    = x
     signum x = x

instance Ord Integer where
   compare x y = primCompareInteger x y 
------------------------------------------------


class (Eq a) => Ord a where
    compare                :: a -> a -> Ordering
    (<), (<=), (>=), (>)   :: a -> a -> Bool
    max, min               :: a -> a -> a

    -- Minimal complete definition: (<=) or compare
    -- 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   | x >= y      = x
	      | otherwise   = y
    min x y   | x <= y      = x
	      | otherwise   = y

class Bounded a where
    minBound, maxBound :: a
    -- Minimal complete definition: All

z = [1,2,3] == [1,2,3]


-----------------------------
class (Eq a) => Num a where
    (+), (-), (*)  :: a -> a -> a
    negate         :: a -> a
    abs, signum    :: a -> a

    -- Minimal complete definition: All, except negate or (-)
    x - y           = x + negate y
    negate x        = 0 - x



------------------------------- LIST
instance Eq a => Eq [a] where
    [] == [] = True
    (x:xs) == (y:ys) = (x==y) && (xs == ys)
    _  == _ = False


--------------------------------------------------------
--------------------------------------------------------
--------------------------------------------------------