Comparaison de haut niveau de l’environnement

Original: http://www.smlnj.org/doc/Conversion/top-level-comparison.html


De SML/NJ 0,93 à SML/NJ 110 (SML 97)
Ce document est une référence rapide pour ceux qui ont besoin de code de port de SML/NJ 0,93 à SML/NJ 110 et les versions ultérieures, qui mettent en oeuvre de la nouvelle de SML 97 base  Standard.
Il devrait également être utile en complément pour ceux qui veulent utiliser les nouvelles versions de SML/NJ en conjonction avec manuels basés sur l’environnement de base SML/NJ 0,93.
Veuillez envoyer des rapports d’erreurs ou des questions concernant ce document à Dave MacQueen à [email protected].
Infixes
Voici les déclarations d’infixe de niveau supérieur pour SML/NJ 0.93 :
  infix 0 before
  infix 3 o :=
  infix 4 = <> > < >= <=
  infixr 5 :: @
  infix 6 + - ^
  infix 7 * / div mod quot rem

 

SML 97 est le même sauf que quot rem ne sont plus des infixes et ne sont pas liés au plus haut niveau (utilisation Int.quot, Int.rem).
Une surcharge
Voici les opérateurs surchargés de 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 élimine makestring et imprimer comme fonctions surchargées. Au plus haut niveau,

  val print = TextIO.print: string -> unit
alors que la makestring surchargée est remplacé par les fonctions Bool.toString, Real.toString et Int.toString.
mod, div sont maintenant surchargées sur les types int et le mot de précisions diverses, et / est surchargé sur diverses précisions de reals. Les autres opérateurs arithmétiques et relationnels sont surchargés sur plusieurs types (par exemple, entiers, mots, nombres réels de différentes tailles). Les opérateurs relationnels sont aussi surchargés sur des chars, mais aussi des chaînes, et on peut potentiellement plus d’une variété de caractères (Ascii, Unicode, par exemple), avec les variétés correspondantes de chaînes.
Remplacement de module
Les anciennes structures de base
  Array
  Bool
  General
  IO
  List
  Real
  RealArray
  String
  Vector

continuent d’exister dans le 97 SML, mais leurs signatures ont changé. La structure du Ref n’existe plus. Les fonctions ! et: = se trouvent désormais en général, tandis que le type ref et la Réf constructeur sont liés uniquement au plus haut niveau. Les structures de base de l’anciens suivantes ont été renommés ou remplacés comme indiqué, encore une fois avec signatures mis à jour le :
  Bits      => Word31
  ByteArray => Word8Array
  Integer   => Int
  IO        => TextIO, BinIO

Bien qu’il est en fait une structure de IO à SML 97, l’ancienne structure de IO correspond à la nouvelle
TextIO et Robel structures.
L’environnement de niveau supérieur
SML/NJ 0,93 ouvre les structures suivantes au plus haut niveau :
  Ref String IO Bool List Integer Real General

 

Il ajoute ensuite les liaisons surchargées et infixe pour créer l’environnement de niveau supérieur. L’environnement de haut niveau comprend également des liaisons de module, qui nous sommes ignorant dans ce document.
Le tableau suivant répertorie les éléments dans l’environnement de niveau supérieur de SML/NJ 0,93 (à l’exclusion des symboles surchargées et déclarations infixe) avec leurs éléments correspondants dans le 97 de SML. Le SML/NJ 0,93 niveau supérieur éléments apparaissent dans la première colonne, regroupés sous les sous-positions correspondant à leurs modules maison à SML/NJ 0,93. La deuxième colonne contient l’élément correspondant de la base de 97 SML (SML/NJ 110). Cela apparaît comme un identificateur simple quand il est aussi lié à haut niveau, caractérisé par son type si différent du type dans la première colonne. Si l’élément correspondant est lié au plus haut niveau, mais provient d’une structure différente, un chemin en italique indique sa structure d’accueil. Si l’élément correspondant n’est pas définie au plus haut niveau, colonne deux contient un chemin d’accès complet (nonitalicized), une fois de plus caractérisé par un type si les types diffèrent.
Lorsque la colonne deux contient un identificateur simple, indiquant qu’il est lié au haut niveau en SML 97 (SML/NJ 110), la troisième colonne donne son accueil module à SML 97.
Entrées dans la colonne deux qui n’ont pas d’entrée correspondante dans la colonne un sont de nouvelles combinaisons de niveau supérieurs absents de la SML/NJ 0,93.
SML/NJ 0.93 SML ’97 (SML/NJ 110)
No structure
eqtype ‘a ref ref
val ref : ‘_a -> ‘_a ref ref : ‘a -> ‘a ref
Ref
val ! : ‘a ref -> ‘a General.!
val := : ‘a ref * ‘a -> unit General.:=
val inc : int ref -> unit
val dec : int ref -> unit
  Char
eqtype char
String
eqtype string string
exception Substring General.Subscript
exception Chr General.Chr
exception Ord
val length : string -> int
val size : string -> int size
val substring : string * int * int -> string substring
val explode : string -> string list explode: string -> char list
val implode : string list -> string implode: char list -> string
val concat: string list -> string
val ^ : string * string -> string ^
val chr : int -> string Char.chr: int -> char
val ord : string -> int Char.ord: char -> int
val ordof : string * int -> int String.sub : string * int -> char
val str: char -> string
IO
type instream TextIO.instream
type outstream TextIO.outstream
exception Io of string IO.Io of {name : string,         function : string,         cause : exn}
val std_in : instream TextIO.stdIn : TextIO.instream
val std_out : outstream TextIO.stdOut : TextIO.outstream
val std_err : outstream TextIO.stdErr : TextIO.outstream
val open_in : string -> instream TextIO.openIn : string -> TextIO.instream
val open_out : string -> outstream TextIO.openOut : string -> TextIO.outstream
val open_append : string -> outstream TextIO.openAppend : string -> TextIO.outstream
val open_string : string -> instream TextIO.openString : string -> TextIO.instream
val close_in : instream -> unit TextIO.closeIn : TextIO.instream -> unit
val close_out : outstream -> unit TextIO.closeOut : TextIO.outstream -> unit
val output : outstream * string -> unit TextIO.output : TextIO.outstream * string -> unit
val outputc : outstream -> string -> unit
val input : instream * int -> string TextIO.inputN : TextIO.instream * int -> string
val inputc : instream -> int -> string
val input_line : instream -> string TextIO.inputLine : TextIO.instream -> string
val lookahead : instream -> string TextIO.lookahead : TextIO.instream -> char option
val end_of_stream : instream -> bool TextIO.endOfStream : TextIO.instream -> bool
val can_input : instream -> int TextIO.canInput : TextIO.instream * int -> bool
val flush_out : outstream -> unit TextIO.flushOut : TextIO.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
val set_term_out : outstream * bool -> unit
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 exportML : string -> bool SMLofNJ.exportML
val exportFn : string * (string list * string list -> unit) -> unit SMLofNJ.exportFn: string * (string * string list -> OS.Process.status) -> ‘a
val TextIO.print: string -> unit
Bool
datatype bool = true | false datatype bool = true | false
datatype ‘a option = NONE | SOME of ‘a Option.optionOption.NONEOption.SOME
val not : bool -> bool not
List
datatype ‘a list = nil | :: of (‘a * ‘a list) datatype ‘a list = nil | :: of (‘a * ‘a list)
exception Empty
exception Hd Empty
exception Tl Empty
exception Nth General.Subscript
exception NthTail General.Subscript
val hd : ‘a list -> ‘a hd
val tl : ‘a list -> ‘a list tl
val null : ‘a list -> bool null
val length : ‘a list -> int length
val @ : ‘a list * ‘a list -> ‘a list @
val rev : ‘a list -> ‘a list rev
val map : (‘a -> ‘b) -> ‘a list -> ‘b list map
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
val app : (‘a -> ‘b) -> ‘a list -> unit app: (‘a -> unit) -> ‘a list -> unit
val revapp : (‘a -> ‘b) -> ‘a list -> unit
val nth : ‘a list * int -> ‘a List.nth
val nthtail : ‘a list * int -> ‘a list List.drop
val exists : (‘a -> bool) -> ‘a list -> bool List.exists
Integer Int
eqtype int int
exception Sum General.Overflow
exception Diff General.Overflow
exception Prod General.Overflow
exception Neg General.Overflow
exception Quot General.Div
exception Abs General.Overflow
exception Div General.Div
exception Mod General.Div
exception Overflow General.Overflow
val div : int * int -> int div (overloaded: Int.div)
val mod : int * int -> int mod (overloaded: Int.mod)
val quot : int * int -> int Int.quot
val rem : int * int -> int Int.rem
val min : int * int -> int Int.min
val max : int * int -> int Int.max
Real
eqtype real type real [not eqtype!]
exception Sum General.Overflow
exception Diff General.Overflow
exception Prod General.Overflow
exception Floor General.Overflow
exception Sqrt General.Overflow
exception Exp General.Overflow
exception Ln General.Overflow
exception Div General.Div
exception Overflow General.Overflow
val / : (real * real) -> real / (Real./,…)
val real : int -> real Real.fromInt
val floor : real -> int floor
val truncate : real -> int trunc
val ceiling : real -> int ceil
val round : real -> int
val sqrt : real -> real Math.sqrt
val sin : real -> real Math.sin
val cos : real -> real Math.cos
val arctan : real -> real Math.atan
val exp : real -> real Math.exp
val ln : real -> real Math.ln
General
type ‘a cont SMLofNJ.cont
type exn type exn
type unit type unit
datatype ‘a frag = QUOTE of string | ANTIQUOTE of ‘a SMLofNJ.fragSMLofNJ.QUOTESMLofNJ.ANTIQUOTE
datatype order = LESS | EQUAL | GREATER
exception Bind Bind
exception Match Match
exception Interrupt
exception Fail of string Fail
exception Option
exception Subscript
exception Chr
exception Div
val use : string -> unit use (= Compiler.Interact.useFile)
val callcc : (‘_a cont -> ‘_a) -> ‘_a SMLofNJ.Cont.callcc : (‘a cont -> ‘a) -> ‘a
val throw : ‘a cont -> ‘a -> ‘b SMLofNJ.Cont.throw
val o : (‘b -> ‘c) * (‘a -> ‘b) -> (‘a -> ‘c) o
val before : (‘a * ‘b) -> ‘a before : (‘a * unit) -> ‘a
val ignore : ‘a -> unit
val exnName : exn -> string
val exnMessage : exn -> string
val = : ”a * ”a -> bool =
val <> : ”a * ”a -> bool <>
  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. La fonction is_term_in peut être définie comme suit :
    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. La fonction is_term_out peut être définie comme suit :
    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

Comments are closed.