-- 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

#-}