Top Level Environment Comparison

Transcription

1 Top Level Environment Comparison From SML/NJ 0.93 to SML/NJ 110 (SML 97) 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 ^ 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

2 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 continue to exist in SML 97, but their signatures have changed. The Ref structure no longer exists. The functions! and := are now found in General, while the type ref and constructor ref are only bound at top level. The following former Basis structures have been renamed or replaced as indicated, again with modified signatures: Bits => Word31 ByteArray => Word8Array Integer => Int IO => TextIO, BinIO Although there actually is an IO structure in SML 97, the old IO structure corresponds to the new TextIO and BinIO structures. The Top Level Environment SML/NJ 0.93 opens the following structures at top level: Ref String IO Bool List Integer Real General It then adds the overloaded bindings and infix bindings to create the top-level environment. The top level environment also includes module bindings, which we are ignoring in this document. 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 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.

3 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 SML/NJ 0.93 SML 97 (SML/NJ 110) No structure eqtype a ref val ref : _a -> _a ref Ref val! : a ref -> a val := : a ref * a -> unit val inc : int ref -> unit val dec : int ref -> unit ref ref : a -> a ref General.! General.:= String eqtype string exception Substring exception Chr exception Ord Char eqtype char string General.Subscript General.Chr val length : string -> int val size : string -> int val substring : string * int * int -> string val explode : string -> string list val implode : string list -> string val ^ : string * string -> string val chr : int -> string val ord : string -> int val ordof : string * int -> int IO type instream type outstream exception Io of string val std_in : instream val std_out : outstream size substring explode: string -> char list implode: char list -> string val concat: string list -> string ^ Char.chr: int -> char Char.ord: char -> int String.sub : string * int -> char val str: char -> string TextIO.instream TextIO.outstream IO.Io of {name : string, function : string, cause : exn} TextIO.stdIn : TextIO.instream TextIO.stdOut : TextIO.outstream

4 val std_err : outstream val open_in : string -> instream val open_out : string -> outstream val open_append : string -> outstream val open_string : string -> instream val close_in : instream -> unit val close_out : outstream -> unit val output : outstream * string -> unit val outputc : outstream -> string -> unit val input : instream * int -> string val inputc : instream -> int -> string val input_line : instream -> string val lookahead : instream -> string TextIO.stdErr : TextIO.outstream TextIO.openIn : string -> TextIO.instrea TextIO.openOut : string -> TextIO.outstr TextIO.openAppend : string -> TextIO.outstream TextIO.openString : string -> TextIO.instream TextIO.closeIn : TextIO.instream -> unit TextIO.closeOut : TextIO.outstream -> un TextIO.output : TextIO.outstream * strin unit TextIO.inputN : TextIO.instream * int -> string TextIO.inputLine : TextIO.instream -> st TextIO.lookahead : TextIO.instream -> ch option val end_of_stream : instream -> bool TextIO.endOfStream : TextIO.instream -> val can_input : instream -> int val flush_out : outstream -> unit val is_term_in : instream -> bool [Note 1] val is_term_out : outstream -> bool [Note 2] val set_term_in : instream * bool -> unit TextIO.canInput : TextIO.instream * int bool TextIO.flushOut : TextIO.outstream -> un val set_term_out : outstream * bool -> unit val execute : (string * string list) -> instream * outstream val execute_in_env : string * string list * string list -> instream * outstream val exportml : string -> bool val exportfn : string * (string list * string list -> unit) -> unit Unix.execute : string * string list -> Unix.proc [Note Unix.executeInEnv : string * string list * string list -> Unix.proc SMLofNJ.exportML SMLofNJ.exportFn: string * (string * string list -> OS.Process.sta -> a val TextIO.print: string -> unit Bool datatype bool = true false datatype a option = NONE SOME of a datatype bool = true false Option.option Option.NONE Option.SOME

5 val not : bool -> bool List datatype a list = nil :: of ( a * a list) not datatype a list = nil :: of ( a * a list) exception Empty exception Hd exception Tl exception Nth exception NthTail val hd : a list -> a val tl : a list -> a list val null : a list -> bool val length : a list -> int : a list * a list -> a list val rev : a list -> a list val map : ( a -> b) -> a list -> b list val fold : ( a * b -> b) -> a list -> b -> b val revfold : ( a * b -> b) -> a list -> b -> b val app : ( a -> b) -> a list -> unit val revapp : ( a -> b) -> a list -> unit val nth : a list * int -> a val nthtail : a list * int -> a list val exists : ( a -> bool) -> a list -> bool Integer eqtype int exception Sum exception Diff exception Prod exception Neg exception Quot exception Abs exception Div exception Mod exception Overflow val div : int * int -> int val mod : int * int -> int val quot : int * int -> int Empty Empty General.Subscript General.Subscript hd tl null rev map foldr : ( a * b -> b) -> b -> a list -> b foldl : ( a * b -> b) -> b -> a list -> b app: ( a -> unit) -> a list -> unit List.nth List.drop List.exists Int int General.Div General.Div General.Div div (overloaded: Int.div) mod (overloaded: Int.mod) Int.quot

6 val rem : int * int -> int val min : int * int -> int val max : int * int -> int Real eqtype real exception Sum exception Diff exception Prod exception Floor exception Sqrt exception Exp exception Ln exception Div exception Overflow val / : (real * real) -> real val real : int -> real val floor : real -> int val truncate : real -> int val ceiling : real -> int val sqrt : real -> real val sin : real -> real val cos : real -> real val arctan : real -> real val exp : real -> real val ln : real -> real General type a cont type exn type unit datatype a frag = QUOTE of string ANTIQUOTE of a Int.rem Int.min Int.max type real [not eqtype!] General.Div / (Real./,...) Real.fromInt floor trunc ceil val round : real -> int Math.sqrt Math.sin Math.cos Math.atan Math.exp Math.ln SMLofNJ.cont type exn type unit SMLofNJ.frag SMLofNJ.QUOTE SMLofNJ.ANTIQUOTE datatype order = LESS EQUAL GREATER exception Bind exception Match exception Interrupt exception Fail of string Bind Match Fail exception Option exception Subscript exception Chr

7 val use : string -> unit exception Div use (= Compiler.Interact.useFile) val callcc : ( _a cont -> _a) -> _a SMLofNJ.Cont.callcc : ( a cont -> a) -> val throw : a cont -> a -> b val o : ( b -> c) * ( a -> b) -> ( a -> c) SMLofNJ.Cont.throw val before : ( a * b) -> a before : ( a * unit) -> a val = : a * a -> bool = val <> : a * a -> bool <> o val ignore : a -> unit val exnname : exn -> string val exnmessage : exn -> string Option datatype a option = NONE SOME of a val getopt : ( a option * a) -> a val issome : a option -> bool val valof : a option -> a Other New SML 97 Elements eqtype Word.word type Substring.substring eqtype a Array.array eqtype a Vector.vector val Vector.vector : a list -> a vector 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)

8 end