(* SML Basis Library and Moscow ML top-level declarations *)

(* SML Basis Library types *)

type     exn
eqtype   unit
datatype order = LESS | EQUAL | GREATER

(* Additional Moscow ML top-level types *)

datatype bool = false | true
eqtype char
eqtype int
datatype 'a option = NONE | SOME of 'a
type ppstream
eqtype real
eqtype string
type substring
type syserror
type 'a vector
eqtype word
eqtype word8
datatype 'a list = nil | op :: of 'a * 'a list
datatype 'a ref  = ref of 'a 
datatype 'a frag = QUOTE of string | ANTIQUOTE of 'a

(* SML Basis Library exceptions *)

exception Bind
exception Chr
exception Div
exception Domain
exception Fail of string
exception Match
exception Overflow
exception Subscript
exception Size

(* Additional Moscow ML top-level exceptions *)

exception Graphic of string
exception Interrupt
exception Invalid_argument of string
exception Io of {function : string, name : string, cause : exn }
exception Out_of_memory
exception SysErr of string * syserror option

(* SML Basis Library values *)

val !          : 'a ref -> 'a
val :=         : 'a ref * 'a -> unit

val o          : ('b -> 'c) * ('a -> 'b) -> ('a -> 'c)
val ignore     : 'a -> unit
val before     : 'a * 'b -> 'a

val exnName    : exn -> string
val exnMessage : exn -> string

(* Additional Moscow ML top-level values *)

val not    : bool -> bool
val ^      : string * string -> string

val =      : ''a * ''a -> bool
val <>     : ''a * ''a -> bool

val ceil   : real -> int                (* round towards plus infinity  *)
val floor  : real -> int                (* round towards minus infinity *)
val real   : int -> real                (* equals Real.fromInt          *)
val round  : real -> int                (* round to nearest even        *)
val trunc  : real -> int                (* round towards zero           *)

val vector : 'a list -> 'a vector

(* Below, numtxt is int, Word.word, Word8.word, real, char, string: *)

val <   : numtxt * numtxt -> bool
val <=  : numtxt * numtxt -> bool
val >   : numtxt * numtxt -> bool
val >=  : numtxt * numtxt -> bool

val makestring : numtxt -> string

(* Below, realint is int or real:                                       *)

val ~   : realint -> realint            (* raises Overflow              *)
val abs : realint -> realint            (* raises Overflow              *)
                                                                        
(* Below, num is int, Word.word, Word8.word, or real:                   *)

val +   : num * num -> num              (* raises Overflow              *)
val -   : num * num -> num              (* raises Overflow              *)
val *   : num * num -> num              (* raises Overflow              *)
val /   : real * real -> real           (* raises Div, Overflow         *)
                                                                        
(* Below, wordint is int, Word.word or Word8.word:                      *)

val div : wordint * wordint -> wordint  (* raises Div, Overflow         *)
val mod : wordint * wordint -> wordint  (* raises Div                   *)

(*
   [exn] is the type of exceptions.
 
   [unit] is the type containing the empty tuple () which equals the 
   empty record { }.

   [order] is used as the return type of comparison functions.

   [bool] is the type of booleans: false and true.  Equals Bool.bool.

   [char] is the type of characters such as #"A".  Equals Char.char.

   [int] is the type of integers.  Equals Int.int.

   [option] is the type of optional values.  Equals Option.option.

   [ppstream] is the type of pretty-printing streams, see structure PP.  
   Pretty-printers may be installed in the top-level by function 
   Meta.installPP; see the Moscow ML Owner's Manual.

   [real] is the type of floating-point numbers.  Equals Real.real.

   [string] is the type of character strings.  Equals String.string.

   [substring] is the type of substrings.  Equals Substring.substring.

   [syserror] is the abstract type of system error codes.  
   Equals OS.syserror. 

   [vector] is the type of immutable vectors.  Equals Vector.vector.
   
   [word] is the type of unsigned words.  Equals Word.word.

   [word8] is the type of unsigned bytes.  Equals Word8.word.

   ['a list] is the type of lists of elements of type 'a.  
   Equals List.list.

   ['a ref] is the type of mutable references to values of type 'a.

   ['a frag] is the type of quotation fragments, resulting from the
   parsing of quotations ` ... ` and antiquotations.  See the Moscow
   ML Owner's Manual.

   [Bind] is the exception raised when the right-hand side value in a
   valbind does not match the left-hand side pattern.

   [Chr] signals an attempt to produce an unrepresentable character.

   [Div] signals an attempt to divide by zero.
   
   [Domain] signals an attempt to apply a function outside its domain
   of definition; such as computing Math.sqrt(~1).

   [Fail] signals the failure of some function, usually in the Moscow
   ML specific library structures.

   [Match] signals the failure to match a value against the patterns
   in a case, handle, or function application.

   [Overflow] signals the attempt to compute an unrepresentable number.

   [Subscript] signals the attempt to use an illegal index in an
   array, dynarray, list, string, substring, vector or weak array.

   [Size] signals the attempt to create an array, string or vector
   that is too large for the implementation.

   [Graphic] signals the failure of Graphics primitives (DOS only).

   [Interrupt] signals user interrupt of the computation.

   [Invalid_argument] signals the failure of a function in the runtime 
   system. 

   [Io { function, name, cause }] signals the failure of an
   input/output operation (function) when operating on a file (name).
   The third field (cause) may give a reason for the failure.

   [Out_of_memory] signals an attempt to create a data structure too
   large for the implementation, or the failure to extend the heap or
   stack.

   [SysErr (msg, err)] signals a system error, described by msg.  A
   system error code may be given by err.  If so, it will usually hold
   that msg = OS.errorMsg err.
  

   SML Basis Library values 

   [! rf] returns the value pointed to by reference rf.

   [:=(rf, e)] evaluates rf and e, then makes the reference rf point to
   the value of e.  Since := has infix status, this is usually written
        rf := e

   [o(f, g)] computes the functional composition of f and g, that is,
   fn x => f(g x).  Since  o  has infix status, this is usually written
        f o g

   [ignore e] evaluates e, discards its value, and returns () : unit.

   [before(e1, e2)] evaluates e1, then evaluates e2, then returns the
   value of e1.  Since  before  has infix status, this is usually written
        e1 before e2

   [exnName exn] returns a name for the exception constructor in exn.  
   Never raises an exception itself.  The name returned may be that of
   any exception constructor aliasing with exn.  For instance,
        let exception E1; exception E2 = E1 in exnName E2 end
   may evaluate to "E1" or "E2".

   [exnMessage exn] formats and returns a message corresponding to
   exception exn.  For the exceptions defined in the SML Basis Library, 
   the message will include the argument carried by the exception.


   Additional Moscow ML top-level values

   [not b] returns the logical negation of b.

   [^] is the string concatenation operator.

   [=] is the polymorphic equality predicate.

   [<>] is the polymorphic inequality predicate.

   [ceil r] is the smallest integer >= r (rounds towards plus infinity).
   May raise Overflow.

   [floor r] is the largest integer <= r (rounds towards minus infinity).
   May raise Overflow.

   [real i] is the floating-point number representing integer i.
   Equivalent to Real.fromInt.

   [round r] is the integer nearest to r, using the default rounding
   mode.  May raise Overflow.

   [trunc r] is the numerically largest integer between r and zero
   (rounds towards zero).  May raise Overflow.

   [vector [x1, ..., xn]] returns the vector #[x1, ..., xn].

   [< (x1, x2)] 
   [<=(x1, x2)]
   [> (x1, x2)]
   [>=(x1, x2)]

   These are the standard comparison operators for arguments of type
   int, Word.word, Word8.word, real, char or string.

   [makestring v] returns a representation of value v as a string, for
   v of type int, Word.word, Word8.word, real, char or string.

   [~ x] is the numeric negation of x (which can be real or int).  May
   raise Overflow.

   [abs x] is the absolute value of x (which can be real or int).  May
   raise Overflow.
                                                                        
   [+ (e1, e2)]
   [- (e1, e2)]
   [* (e1, e2)]

   These are the standard arithmetic operations for arguments of type
   int, Word.word, Word8.word, and real.  They are unsigned in the
   case of Word.word and Word8.word.  May raise Overflow.

   [/ (e1, e2)] is the floating-point result of dividing e1 by e2.
   May raise Div and Overflow.
                                                                        
   [div(e1, e2)] is the integral quotient of dividing e1 by e2 for
   arguments of type int, Word.word, and Word8.word.  See Int.div and
   Word.div for more details.  May raise Div, Overflow.

   [mod(e1, e2)] is the remainder when dividing e1 by e2, for
   arguments of type int, Word.word, and Word8.word.  See Int.mod and
   Word.mod for more details.  May raise Div.
*)
