*** Quoted from original distrinution files ***

Edinburgh Standard ML                                 (C) Edinburgh University

This version contains an experimental implementation of equality types
and the 
   'datatype db <<using tb>>' construct.


- = > datatype TimeStamp = TimeStamp of { HostId:int, ProcessId:int, Time:int
 }
  datatype Stamped = File of string | Functor of string | Now | Signature of 
string | Structure of string
  exception TimeStampOf : unit
  val usestring = fn : (string list) -> unit
  val use = fn : (string list) -> unit
  val system = fn : string -> int
  val getenv = fn : string -> string
  val collect = fn : 'a -> 'a
  val TimeStampOf = fn : Stamped -> TimeStamp
  con TimeStamp = fn : { HostId:int, ProcessId:int, Time:int } -> TimeStamp
  con Structure = fn : string -> Stamped
  con Signature = fn : string -> Stamped
  val Print = { Depth=ref 1, ObjectCode=ref(false), ParseTree=ref(false), 
Space=ref(false), StackCode=ref(false), Timings=ref(false), TraceML=ref(false)
, Types=ref(true), Use=ref{| some |}, VarNames=ref(true), VarTypes=ref(true), 
VarValues=ref(true) } : { Depth:int ref, ObjectCode:bool ref, ParseTree:bool 
ref, Space:bool ref, StackCode:bool ref, Timings:bool ref, TraceML:bool ref, 
Types:bool ref, Use:{| all, none, some |} ref, VarNames:bool ref, VarTypes:
bool ref, VarValues:bool ref }
  con Now = Now : Stamped
  val ML = fn : unit -> unit
  con Functor = fn : string -> Stamped
  con File = fn : string -> Stamped
  val ExportML = fn : (string * string * (string list)) -> unit
  val ExportFunction = fn : (string * (unit -> unit) * int) -> unit
  val Debug = { CheckMatch=ref(true), ExcEnv=ref(false), FunEnv=ref(false), 
InhibitNewOverloadings=ref(true), InhibitUpdates=ref(false), InlineCode=ref 10
, NewRules=ref(false), Optimise=ref(true), SigEnv=ref(false), StrEnv=ref(false
), TimeStamps=ref(false), TypeEnv=ref(false), TypeSharing=ref(true), 
TypeVariables=ref(false), ValEnv=ref(false) } : { CheckMatch:bool ref, ExcEnv:
bool ref, FunEnv:bool ref, InhibitNewOverloadings:bool ref, InhibitUpdates:
bool ref, InlineCode:int ref, NewRules:bool ref, Optimise:bool ref, SigEnv:
bool ref, StrEnv:bool ref, TimeStamps:bool ref, TypeEnv:bool ref, TypeSharing:
bool ref, TypeVariables:bool ref, ValEnv:bool ref }
  val CurrentState = fn : unit -> { ActiveStreams:unit, BuiltInExceptions:(
string ref) array, CompactGC:bool ref, EmptyArray:unit array, EmptyTok:string
, FunCompText:text[hidden], FunIdClosure:closure[hidden], GCMsgs:bool ref, 
StartupClosure:closure[hidden], StdErr:outstream, StdIn:instream, StdOut:
outstream, WaitingProcesses:unit }
  val CpuTime = fn : unit -> int
- = > structure String = 
    struct
      type string
      exception chr : unit
      exception ord : unit
      val < = fn : (string * string) -> bool
      val <= = fn : (string * string) -> bool
      val > = fn : (string * string) -> bool
      val >= = fn : (string * string) -> bool
      val ^ = fn : (string * string) -> string
      val chr = fn : int -> string
      val explode = fn : string -> (string list)
      val implode = fn : (string list) -> string
      val length = fn : string -> int
      val ord = fn : string -> int
      val ordof = fn : (string * int) -> int
      val size = fn : string -> int
      val substring = fn : (string * int * int) -> string
    end
  structure Ref = 
    struct
      datatype '_a ref = ref of '_a
      val ! = fn : ('a ref) -> 'a
      val := = fn : (('a ref) * 'a) -> unit
      val dec = fn : (int ref) -> unit
      val inc = fn : (int ref) -> unit
      con ref = fn : '_a -> ('_a ref)
    end
  structure Real = 
    struct
      type real
      exception exp : unit
      exception floor : unit
      exception ln : unit
      exception sqrt : unit
      val * = fn : (real * real) -> real
      val + = fn : (real * real) -> real
      val - = fn : (real * real) -> real
      val / = fn : (real * real) -> real
      val < = fn : (real * real) -> bool
      val <= = fn : (real * real) -> bool
      val > = fn : (real * real) -> bool
      val >= = fn : (real * real) -> bool
      val abs = fn : real -> real
      val arctan = fn : real -> real
      val cos = fn : real -> real
      val exp = fn : real -> real
      val floor = fn : real -> int
      val ln = fn : real -> real
      val makestring = fn : real -> string
      val real = fn : int -> real
      val sin = fn : real -> real
      val sqrt = fn : real -> real
      val ~ = fn : real -> real
    end
  structure Pfl = 
    struct
      type beh = beh
      type 'a chan = 'a chan
      val & = fn : (beh * beh) -> beh
      val + = fn : (beh * beh) -> beh
      val NIL = - : beh
      val exec = fn : beh -> unit
      val pexec = fn : beh -> unit
      val pfl_newport = fn : unit -> ('_a chan)
      val pfl_read = fn : (('a chan) * ('a -> beh)) -> beh
      val pfl_write = fn : (('a chan) * 'a * (unit -> beh)) -> beh
    end
  structure Output = 
    struct
      val check_minimum_fn = ref fn : (int -> unit) ref
      val flush_fn = ref fn : (unit -> unit) ref
      val lineterm = ref "
" : string ref
      val newline_fn = ref fn : (int -> unit) ref
      val output_string_fn = ref fn : (string -> unit) ref
    end
  structure List = 
    struct
      datatype 'a list = :: of 'a * ('a list) | nil
      con :: = fn : ('a * ('a list)) -> ('a list)
      val @ = fn : (('a list) * ('a list)) -> ('a list)
      val app = fn : ('a -> 'b) -> (('a list) -> unit)
      val exists = fn : (('a -> bool) * ('a list)) -> bool
      val fold = fn : (('a * 'b) -> 'b) -> (('a list) -> ('b -> 'b))
      val hd = fn : ('a list) -> 'a
      val length = fn : ('a list) -> int
      val map = fn : ('a -> 'b) -> (('a list) -> ('b list))
      con nil = [] : 'a list
      val nth = fn : (('a list) * int) -> 'a
      val null = fn : ('a list) -> bool
      val rev = fn : ('a list) -> ('a list)
      val revapp = fn : ('a -> unit) -> (('a list) -> unit)
      val revfold = fn : (('a * 'b) -> 'b) -> (('a list) -> ('b -> 'b))
      val tl = fn : ('a list) -> ('a list)
    end
  structure Integer = 
    struct
      type int
      val * = fn : (int * int) -> int
      val + = fn : (int * int) -> int
      val - = fn : (int * int) -> int
      val < = fn : (int * int) -> bool
      val <= = fn : (int * int) -> bool
      val > = fn : (int * int) -> bool
      val >= = fn : (int * int) -> bool
      val abs = fn : int -> int
      val div = fn : (int * int) -> int
      val makestring = fn : int -> string
      val max = fn : (int * int) -> int
      val min = fn : (int * int) -> int
      val mod = fn : (int * int) -> int
      val ~ = fn : int -> int
    end
  structure Dynamic = 
    struct
      type Dynamic
    end
  structure Bool = 
    struct
      datatype bool = false | true
      con false = false : bool
      val makestring = fn : bool -> string
      val not = fn : bool -> bool
      con true = true : bool
    end
  structure BasicIO = 
    struct
      type instream = instream
      type outstream = outstream
      exception io_failure : string
      val close_in = fn : instream -> unit
      val close_out = fn : outstream -> unit
      val end_of_stream = fn : instream -> bool
      val input = fn : (instream * int) -> string
      val input_line = fn : instream -> string
      val lookahead = fn : instream -> string
      val open_in = fn : string -> instream
      val open_out = fn : string -> outstream
      val output = fn : (outstream * string) -> unit
      val std_in = - : instream
      val std_out = - : outstream
    end
  structure Array = 
    struct
      type '_a array
      exception subscript : unit
      val array = fn : (int * '_a) -> ('_a array)
      val arrayoflist = fn : ('_a list) -> ('_a array)
      val length = fn : ('a array) -> int
      val sub = fn : (('a array) * int) -> 'a
      val update = fn : (('a array) * int * 'a) -> unit
    end
  val o = fn : (('a -> 'b) * ('c -> 'a)) -> ('c -> 'b)
- 

*** end of quotation ***