-- interface.scm -- define interface to primitives
 --
 -- author :  Sandra & John
 -- date   :  24 Apr 1992
 --
 -- This file declares the interface to the runtime system primitives.
 -- The actual definitions for the Lisp functions all appear elsewhere;
 -- they all have names like prim.xxx.  (They can actually be macros
 -- instead of functions since they're never referenced by name.)
 
 interface PreludePrims where
 
 {-# Prelude #-}
 
 import PreludeCore(Int,Integer,Float,Double,Char,Bool)
 import PreludeRational(Rational)
 
 error :: String -> a
 primCharToInt :: Char -> Int
 primIntToChar :: Int -> Char
 primEqChar, primNeqChar, primLeChar, primGtChar, primLsChar, primGeChar
   :: Char -> Char -> Bool
 primMaxChar :: Int
 primEqFloat, primNeqFloat, primLeFloat, primGtFloat, primLsFloat, primGeFloat
   :: Float -> Float -> Bool
 primFloatMax, primFloatMin :: Float -> Float -> Float
 primEqDouble, primNeqDouble, primLeDouble, primGtDouble, 
               primLsDouble, primGeDouble
   :: Double -> Double -> Bool
 primDoubleMax, primDoubleMin :: Double -> Double -> Double
 primPlusFloat, primMinusFloat, primMulFloat, primDivFloat
   :: Float -> Float -> Float
 primPlusDouble, primMinusDouble, primMulDouble, primDivDouble
   :: Double -> Double -> Double
 primNegFloat, primAbsFloat :: Float -> Float
 primNegDouble, primAbsDouble :: Double -> Double
 primExpFloat, primLogFloat, primSqrtFloat, primSinFloat, primCosFloat,
   primTanFloat, primAsinFloat, primAcosFloat, primAtanFloat, primSinhFloat,
   primCoshFloat, primTanhFloat, primAsinhFloat, primAcoshFloat, primAtanhFloat
   :: Float -> Float
 primExpDouble, primLogDouble, primSqrtDouble, primSinDouble, primCosDouble,
   primTanDouble, primAsinDouble, primAcosDouble, primAtanDouble, primSinhDouble,
   primCoshDouble, primTanhDouble, primAsinhDouble, primAcoshDouble, primAtanhDouble
   :: Double -> Double
 primPiFloat :: Float
 primPiDouble :: Double
 primRationalToFloat :: Rational -> Float
 primRationalToDouble :: Rational -> Double
 primFloatToRational :: Float -> Rational
 primDoubleToRational :: Double -> Rational
 primFloatDigits :: Int
 primFloatRadix :: Integer
 primFloatMinExp :: Int
 primFloatMaxExp :: Int
 primFloatRange :: Float -> (Int, Int)
 primDecodeFloat :: Float -> (Integer, Int)
 primEncodeFloat :: Integer -> Int -> Float
 primDoubleDigits :: Int
 primDoubleRadix :: Integer
 primDoubleMinExp :: Int
 primDoubleMaxExp :: Int
 primDoubleRange :: Double -> (Int, Int)
 primDecodeDouble :: Double -> (Integer, Int)
 primEncodeDouble :: Integer -> Int -> Double
 primEqInt, primNeqInt, primLeInt, primGtInt, primLsInt, primGeInt
   :: Int -> Int -> Bool
 primIntMax, primIntMin :: Int -> Int -> Int
 primEqInteger, primNeqInteger, primLeInteger, primGtInteger,
   primLsInteger, primGeInteger
     :: Integer -> Integer -> Bool
 primIntegerMax, primIntegerMin :: Integer -> Integer -> Integer
 primPlusInt, primMinusInt, primMulInt :: Int -> Int -> Int 
 primMinInt,primMaxInt :: Int
 primNegInt, primAbsInt :: Int -> Int
 primPlusInteger, primMinusInteger, primMulInteger :: Integer -> Integer -> Integer 
 primNegInteger, primAbsInteger :: Integer -> Integer
 primQuotRemInt :: Int -> Int -> (Int, Int)
 primQuotRemInteger :: Integer -> Integer -> (Integer, Integer)
 primIntegerToInt :: Integer -> Int
 primIntToInteger :: Int -> Integer
 primNullBin :: Bin
 primIsNullBin :: Bin -> Bool
 primShowBinInt :: Int -> Bin -> Bin
 primShowBinInteger :: Integer -> Bin -> Bin
 primShowBinFloat :: Float -> Bin -> Bin
 primShowBinDouble :: Double -> Bin -> Bin
 primReadBinInt :: Bin -> (Int,Bin)
 primReadBinInteger :: Bin -> (Integer,Bin)
 primReadBinFloat :: Bin -> (Float,Bin)
 primReadBinDouble :: Bin -> (Double,Bin)
 primReadBinSmallInt :: Bin -> Int -> (Int,Bin)
 primAppendBin :: Bin -> Bin -> Bin
 
 primStringEq  :: [Char] -> [Char] -> Bool
 
 primAppend :: [a] -> [a] -> [a]
 primTake :: Int -> [a] -> [a]
 
 foldr :: (a -> b -> b) -> b -> [a] -> b
 build :: ((a -> [a] -> [a]) -> [b] -> [c]) -> [c]
 
 
 
 -- I've assigned complexities for arithmetic primitives as follows:
 -- Int and Char comparisons and arithmetic are very cheap (complexity 1).
 -- Double and Float comparsions are also cheap, but most implementations
 --   need to box the results of floating-point arithmetic so I have given
 --   them a complexity of 3.
 -- Integer operations need to do an extra bignum check that has a fixed
 --   overhead.  I assume that actual bignums will be rare and give them
 --   all a complexity of 2.
 
 {-#
 error :: LispName("prim.abort")
 primCharToInt ::    LispName("prim.char-to-int"), Complexity(0),NoConversion
 primIntToChar ::    LispName("prim.int-to-char"), Complexity(0),NoConversion
 primEqChar ::       LispName("prim.eq-char"), Complexity(1), NoConversion
 primNeqChar::       LispName("prim.not-eq-char"), Complexity(1), NoConversion
 primLeChar ::       LispName("prim.le-char"), Complexity(1), NoConversion
 primGtChar ::       LispName("prim.not-le-char"), Complexity(1), NoConversion
 primLsChar ::       LispName("prim.lt-char"), Complexity(1), NoConversion
 primGeChar ::       LispName("prim.not-lt-char"), Complexity(1), NoConversion
 primMaxChar ::      LispName("prim.max-char"), NoConversion
 primEqFloat ::      LispName("prim.eq-float"), Complexity(1)
 primNeqFloat ::     LispName("prim.not-eq-float"), Complexity(1)
 primLeFloat  ::     LispName("prim.le-float"), Complexity(1)
 primGtFloat  ::     LispName("prim.not-le-float"), Complexity(1)
 primLsFloat  ::     LispName("prim.lt-float"), Complexity(1)
 primGeFloat  ::     LispName("prim.not-lt-float"), Complexity(1)
 primFloatMax ::     LispName("prim.float-max"), Complexity(3)
 primFloatMin ::     LispName("prim.float-min"), Complexity(3)
 primEqDouble  ::    LispName("prim.eq-double"), Complexity(1)
 primNeqDouble ::    LispName("prim.not-eq-double"), Complexity(1)
 primLeDouble  ::    LispName("prim.le-double"), Complexity(1)
 primGtDouble  ::    LispName("prim.not-le-double"), Complexity(1)
 primLsDouble  ::    LispName("prim.lt-double"), Complexity(1)
 primGeDouble  ::    LispName("prim.not-lt-double"), Complexity(1)
 primDoubleMax ::    LispName("prim.double-max"), Complexity(3)
 primDoubleMin ::    LispName("prim.double-min"), Complexity(3)
 primPlusFloat  ::   LispName("prim.plus-float"), Complexity(3)
 primMinusFloat ::   LispName("prim.minus-float"), Complexity(3)
 primMulFloat   ::   LispName("prim.mul-float"), Complexity(3)
 primDivFloat   ::   LispName("prim.div-float"), Complexity(3)
 primPlusDouble  ::  LispName("prim.plus-double"), Complexity(3)
 primMinusDouble ::  LispName("prim.minus-double"), Complexity(3)
 primMulDouble   ::  LispName("prim.mul-double"), Complexity(3)
 primDivDouble   ::  LispName("prim.div-double"), Complexity(3)
 primNegFloat ::     LispName("prim.neg-float"), Complexity(3)
 primAbsFloat ::     LispName("prim.abs-float"), Complexity(3)
 primNegDouble ::    LispName("prim.neg-double"), Complexity(3)
 primAbsDouble ::    LispName("prim.abs-double"), Complexity(3)
 primExpFloat   ::   LispName("prim.exp-float")
 primLogFloat   ::   LispName("prim.log-float")
 primSqrtFloat  ::   LispName("prim.sqrt-float")
 primSinFloat   ::   LispName("prim.sin-float")
 primCosFloat   ::   LispName("prim.cos-float")
 primTanFloat   ::   LispName("prim.tan-float")
 primAsinFloat  ::   LispName("prim.asin-float")
 primAcosFloat  ::   LispName("prim.acos-float")
 primAtanFloat  ::   LispName("prim.atan-float")
 primSinhFloat  ::   LispName("prim.sinh-float")
 primCoshFloat  ::   LispName("prim.cosh-float")
 primTanhFloat  ::   LispName("prim.tanh-float")
 primAsinhFloat ::   LispName("prim.asinh-float")
 primAcoshFloat ::   LispName("prim.acosh-float")
 primAtanhFloat ::   LispName("prim.atanh-float")
 primExpDouble   ::  LispName("prim.exp-double")
 primLogDouble   ::  LispName("prim.log-double")
 primSqrtDouble  ::  LispName("prim.sqrt-double")
 primSinDouble   ::  LispName("prim.sin-double")
 primCosDouble   ::  LispName("prim.cos-double")
 primTanDouble   ::  LispName("prim.tan-double")
 primAsinDouble  ::  LispName("prim.asin-double")
 primAcosDouble  ::  LispName("prim.acos-double")
 primAtanDouble  ::  LispName("prim.atan-double")
 primSinhDouble  ::  LispName("prim.sinh-double")
 primCoshDouble  ::  LispName("prim.cosh-double")
 primTanhDouble  ::  LispName("prim.tanh-double")
 primAsinhDouble ::  LispName("prim.asinh-double")
 primAcoshDouble ::  LispName("prim.acosh-double")
 primAtanhDouble ::  LispName("prim.atanh-double")
 primPiFloat ::      LispName("prim.pi-float")
 primPiDouble ::     LispName("prim.pi-double")
 primRationalToFloat  :: LispName("prim.rational-to-float"), Complexity(3)
 primRationalToDouble :: LispName("prim.rational-to-double"), Complexity(3)
 primFloatToRational  :: LispName("prim.float-to-rational"), Complexity(3)
 primDoubleToRational :: LispName("prim.double-to-rational"), Complexity(3)
 primFloatDigits ::  LispName("prim.float-digits")
 primFloatRadix ::   LispName("prim.float-radix")
 primFloatMinExp ::  LispName("prim.float-min-exp")
 primFloatMaxExp ::  LispName("prim.float-max-exp")
 primFloatRange ::   LispName("prim.float-range")
 primDecodeFloat ::  LispName("prim.decode-float")
 primEncodeFloat ::  LispName("prim.encode-float")
 primDoubleDigits :: LispName("prim.double-digits")
 primDoubleRadix ::  LispName("prim.double-radix")
 primDoubleMinExp :: LispName("prim.double-min-exp")
 primDoubleMaxExp :: LispName("prim.double-max-exp")
 primDoubleRange ::  LispName("prim.double-range")
 primDecodeDouble :: LispName("prim.decode-double")
 primEncodeDouble :: LispName("prim.encode-double")
 primEqInt ::        LispName("prim.eq-int"), Complexity(1)
 primNeqInt::        LispName("prim.not-eq-int"), Complexity(1)
 primLeInt ::        LispName("prim.le-int"), Complexity(1)
 primGtInt ::        LispName("prim.not-le-int"), Complexity(1)
 primLsInt ::        LispName("prim.lt-int"), Complexity(1)
 primGeInt ::        LispName("prim.not-lt-int"), Complexity(1)
 primIntMax ::       LispName("prim.int-max"), Complexity(1)
 primIntMin ::       LispName("prim.int-min"), Complexity(1)
 primEqInteger ::    LispName("prim.eq-integer"), Complexity(2)
 primNeqInteger::    LispName("prim.not-eq-integer"), Complexity(2)
 primLeInteger ::    LispName("prim.le-integer"), Complexity(2)
 primGtInteger ::    LispName("prim.not-le-integer"), Complexity(2)
 primLsInteger ::    LispName("prim.lt-integer"), Complexity(2)
 primGeInteger ::    LispName("prim.not-lt-integer"), Complexity(2)
 primIntegerMax ::   LispName("prim.integer-max"), Complexity(2)
 primIntegerMin ::   LispName("prim.integer-min"), Complexity(2)
 primPlusInt  ::     LispName("prim.plus-int"), Complexity(1)
 primMinusInt ::     LispName("prim.minus-int"), Complexity(1)
 primMulInt   ::     LispName("prim.mul-int"), Complexity(1)
 primMinInt ::       LispName("prim.minint")
 primMaxInt ::       LispName("prim.maxint")
 primNegInt ::       LispName("prim.neg-int"), Complexity(1)
 primAbsInt ::       LispName("prim.abs-int"), Complexity(1)
 primPlusInteger  :: LispName("prim.plus-integer"), Complexity(2)
 primMinusInteger :: LispName("prim.minus-integer"), Complexity(2)
 primMulInteger   :: LispName("prim.mul-integer"), Complexity(2)
 primNegInteger ::   LispName("prim.neg-integer"), Complexity(2)
 primAbsInteger ::   LispName("prim.abs-integer"), Complexity(2)
 primQuotRemInt ::   LispName("prim.div-rem-int")
 primQuotRemInteger :: LispName("prim.div-rem-integer")
 primIntegerToInt :: LispName("prim.integer-to-int"), Complexity(1)
 primIntToInteger :: LispName("prim.int-to-integer"), Complexity(0)
 primNullBin ::      LispName("prim.nullbin")
 primIsNullBin ::    LispName("prim.is-null-bin"), Complexity(1)
 primShowBinInt ::   LispName("prim.show-bin-int"), Complexity(2)
 primShowBinInteger :: LispName("prim.show-bin-integer"), Complexity(2)
 primShowBinFloat ::   LispName("prim.show-bin-float"), Complexity(2)
 primShowBinDouble ::  LispName("prim.show-bin-double"), Complexity(2)
 primReadBinInt ::     LispName("prim.read-bin-int")
 primReadBinInteger :: LispName("prim.read-bin-integer")
 primReadBinFloat ::   LispName("prim.read-bin-float")
 primReadBinDouble ::  LispName("prim.read-bin-double")
 primReadBinSmallInt :: LispName("prim.read-bin-small-int")
 primAppendBin ::      LispName("prim.append-bin")
 primStringEq :: LispName("prim.string-eq"), Strictness("S,S"), NoConversion
 primAppend :: LispName("prim.append"), Strictness("S,N"), NoConversion
 primTake   :: LispName("prim.take"), Strictness("S,S"), NoConversion
 foldr   :: LispName("prim.foldr"), Strictness("N,N,S"), NoConversion
 build   :: LispName("prim.build"), Strictness("S"), NoConversion
 
 #-}