Top Level Environment Comparison

This document is a quick reference for those who need to port code from SML/NJ 0.93 to SML/NJ 110 and later versions, which implement the new SML '97 Standard Basis.

It should also be useful as a supplement for those who want to use new versions of SML/NJ in conjunction with textbooks based on the SML/NJ 0.93 Basis environment.

Please send any error reports or questions regarding this document to Dave MacQueen at dbm@research.bell-labs.com.

Infixes

Here are the top level infix declarations for SML/NJ 0.93:

  infix 0 before
  infix 3 o :=
  infix 4 = <> > < >= <=
  infixr 5 :: @
  infix 6 + - ^
  infix 7 * / div mod quot rem

SML '97 is the same except that quot and rem are no longer infixes, and are not bound at top level (use Int.quot, Int.rem).

Overloading

Here are the overloaded operators of 0.93:

  makestring : ('a -> string) {Bool.makestring, Real.makestring, Integer.makestring}
  print : ('a -> unit)    {Bool.print, Integer.print, Real.print, String.print}
  ~ :   ('a -> 'a)        {Integer.~, Real.~}
  + :   ('a * 'a -> 'a)   {Integer.+, Real.+}
  - :   ('a * 'a -> 'a)   {Integer.-, Real.-}
  * :   ('a * 'a -> 'a)   {Integer.*, Real.*}
  < :   ('a * 'a -> bool) {Integer.<, Real.<, String.<}
  > :   ('a * 'a -> bool) {Integer.>, Real.>, String.>}
  <= :  ('a * 'a -> bool) {Integer.<=, Real.<=, String.<=}
  >= :  ('a * 'a -> bool) {Integer.>=, Real.>=, String.>=}
  abs : ('a -> 'a)        {Integer.abs, Real.abs}

SML '97 eliminates makestring and print as overloaded functions. At top level,

      val print = TextIO.print: string -> unit

while the overloaded makestring is replaced by the functions Bool.toString, Real.toString, and Int.toString.

mod, div are now overloaded on int and word types of various precisions, and / is overloaded on various precisions of reals. The other arithmetic and relational operators are overloaded on more types (e.g. integers, words, reals of various sizes). The relational operators are also overloaded on chars as well as strings, and there can potentially be more than one variety of chars (e.g. Ascii, Unicode), with corresponding varieties of strings.

Module Replacements

The former Basis structures

  Array
  Bool
  General
  IO
  List
  Real
  RealArray
  String
  Vector

  Bits      => Word31
  ByteArray => Word8Array
  Integer   => Int
  IO        => TextIO, BinIO

The Top Level Environment

SML/NJ 0.93 opens the following structures at top level:

  Ref String IO Bool List Integer Real General

The following table lists the elements in the SML/NJ 0.93 top-level environment (excluding overloaded symbols and infix declarations) with their corresponding elements in SML '97. The SML/NJ 0.93 top-level elements appear in the first column, grouped under subheadings corresponding to their home modules in SML/NJ 0.93. The second column gives the corresponding element of the SML '97 (SML/NJ 110) Basis. This is displayed as a simple identifier when it is also bound at top level, annotated by its type if different from the type in the first column. If the corresponding element is bound at top level, but comes from a different structure, a path in italics indicates its home structure. If the corresponding element is not defined at top level, column two contains a full path (nonitalicized), once again annotated by a type if the types differ.

When column two contains a simple identifier, indicating it is bound at the top level in SML '97 (SML/NJ 110), the third column gives its home module in SML '97.

Entries in column two that do not have a corresponding entry in column one are new top level bindings not present in SML/NJ 0.93.

IO.Io of {name : string,
          function : string,
          cause : exn}

val execute :
 (string * string list)
 -> instream * outstream

Unix.execute :
 string * string list -> Unix.proc [Note 3]

val execute_in_env :
 string * string list * string list
 -> instream * outstream

Unix.executeInEnv :
 string * string list * string list
 -> Unix.proc

val exportFn :
 string *
 (string list * string list -> unit)
 -> unit					    

SMLofNJ.exportFn: 
 string *
 (string * string list -> OS.Process.status)
 -> 'a

datatype bool = true | false

datatype bool = true | false

datatype 'a option = NONE | SOME of 'a

Option.option
Option.NONE
Option.SOME

datatype 'a list
  = nil
  | :: of ('a * 'a list)

datatype 'a list
  = nil
  | :: of ('a * 'a list)

val fold :
 ('a * 'b -> 'b) -> 'a list
 -> 'b -> 'b

foldr :
 ('a * 'b -> 'b) -> 'b
 -> 'a list -> 'b

val revfold :
 ('a * 'b -> 'b) -> 'a list
 -> 'b -> 'b

foldl :
 ('a * 'b -> 'b) -> 'b
 -> 'a list -> 'b

datatype 'a frag
  = QUOTE of string
  | ANTIQUOTE of 'a

SMLofNJ.frag
SMLofNJ.QUOTE
SMLofNJ.ANTIQUOTE

datatype order
  = LESS | EQUAL | GREATER

Notes

1. The is_term_in function can be defined as follows:

       fun is_term_in (instream : TextIO.instream) =
   	let val (rd as TextPrimIO.RD{ioDesc,...}, buf) =
   		 TextIO.StreamIO.getReader(TextIO.getInstream instream)
   	 in TextIO.setInstream (instream, TextIO.StreamIO.mkInstream(rd, SOME buf));
   	    case ioDesc
   	      of NONE => false
   	       | SOME desc => (OS.IO.kind desc = OS.IO.Kind.tty)
   	end
   

2. The is_term_out function can be defined as follows:

       fun is_term_out (outstream: TextIO.outstream) =
           let val (wr as TextPrimIO.WR{ioDesc,...},buf) =
   	        TextIO.StreamIO.getWriter(TextIO.getOutstream outstream)
            in TextIO.setOutstream (outstream, TextIO.StreamIO.mkOutstream(wr,buf));
   	    case ioDesc
   	      of NONE => false
   	       | SOME desc => (OS.IO.kind desc = OS.IO.Kind.tty)
           end