[MLton-commit] r4970

[Stephen W. <sw...@ml...>]

Eliminated top-level type abbreviations.

----------------------------------------------------------------------

U   mltonlib/trunk/com/sweeks/basic/unstable/EXPORT
U   mltonlib/trunk/com/sweeks/basic/unstable/array.0.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/basis.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/bit-flags.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/bool.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/bool.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/char.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/char.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/date.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/dir.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/dir.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/enumerable.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/enumerate-get.fun
U   mltonlib/trunk/com/sweeks/basic/unstable/enumerate.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/exn.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/exn.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/export.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/export.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/fields-and-tokens.fun
U   mltonlib/trunk/com/sweeks/basic/unstable/file.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/file.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/generic-array.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/generic-slice.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/generic-vector.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/get.fun
U   mltonlib/trunk/com/sweeks/basic/unstable/get.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/in.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/int.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/io-desc.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/lib.mlb
U   mltonlib/trunk/com/sweeks/basic/unstable/list.0.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/list.1.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/list.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/net.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/net.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/open-export.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/option.0.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/option.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/order.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/ordered.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/out.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/packable-real.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/packable-word.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/path.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/path.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/poll.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/posix.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/process.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/radix.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/ram-sequence.fun
U   mltonlib/trunk/com/sweeks/basic/unstable/real-structs.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/real.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/ref.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/ref.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/scanner.0.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/scanner.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/seq.0.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/seq.2.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/seq.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/sequence.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/slice.fun
U   mltonlib/trunk/com/sweeks/basic/unstable/sliceable.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/static-sum.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/static-sum.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/string.1.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/string.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/substring.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/substring.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/sys-error.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/sys-error.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/thunk.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/thunk.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/time.sig
A   mltonlib/trunk/com/sweeks/basic/unstable/unit.sig
A   mltonlib/trunk/com/sweeks/basic/unstable/unit.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/util.sig
U   mltonlib/trunk/com/sweeks/basic/unstable/vector.sml
U   mltonlib/trunk/com/sweeks/basic/unstable/word.sig

----------------------------------------------------------------------

Modified: mltonlib/trunk/com/sweeks/basic/unstable/EXPORT
===================================================================
--- mltonlib/trunk/com/sweeks/basic/unstable/EXPORT	2006-12-11 03:36:48 UTC (rev 4969)
+++ mltonlib/trunk/com/sweeks/basic/unstable/EXPORT	2006-12-11 04:56:50 UTC (rev 4970)
@@ -1,40 +1,27 @@
-type 'a array = 'a array
-datatype bool = false | true
-eqtype char = char
-type exn = exn
-eqtype int = int
-datatype 'a list = nil | :: of 'a * 'a list
-datatype 'a option = None | Some of 'a
-datatype order = Equal | Greater | Less
-type 'a seq = 'a seq
-eqtype string = string
-type 'a thunk = unit -> 'a
-eqtype unit = unit
-eqtype 'a vector = 'a vector
-eqtype word = word
+eqtype z = unit
 val * : ('a * 'a) -> 'a
 val + : ('a * 'a) -> 'a
 val - : ('a * 'a) -> 'a
 val / : ('a * 'a) -> 'a
-val < : ('a * 'a) -> bool
-val <= : ('a * 'a) -> bool
-val <> : ('a * 'a) -> bool
-val = : ('a * 'a) -> bool
-val > : ('a * 'a) -> bool
-val >= : ('a * 'a) -> bool
-val @ : ('a list * 'a list) -> 'a list
+val < : ('a * 'a) -> Bool.t
+val <= : ('a * 'a) -> Bool.t
+val <> : ('a * 'a) -> Bool.t
+val = : ('a * 'a) -> Bool.t
+val > : ('a * 'a) -> Bool.t
+val >= : ('a * 'a) -> Bool.t
+val @ : ('a List.t * 'a List.t) -> 'a List.t
 val abs: 'a -> 'a
-val concat: string seq -> string
+val concat: string Seq.t -> string
 val die: string -> 'a
 val div: ('a * 'a) -> 'a
 val finally: ((unit -> 'a) * (unit -> unit)) -> 'a
 val ignore: 'a -> unit
 val lazy: (unit -> 'a) -> (unit -> 'a)
 val mod: ('a * 'a) -> 'a
-val not: bool -> bool
+val not: Bool.t -> Bool.t
 val o: (('a -> 'b) * ('c -> 'a)) -> ('c -> 'b)
 val print: string -> unit
-val valOf: 'a option -> 'a
+val valOf: 'a Option.t -> 'a
 val ~ : 'a -> 'a
 structure Array: ARRAY
 		 where type 'a elem = 'a
@@ -47,7 +34,7 @@
 		      where type 'a t = 'a ArraySlice.t
 structure Bool: BOOL
 structure Char: CHAR
-		where type t = char
+		where type t = Char.t
 structure CommandLine: COMMAND_LINE
 structure Date: DATE
 		where type Month.t = Date.Month.t
@@ -58,34 +45,34 @@
 structure Endian: ENDIAN
 		  where type t = Endian.t
 structure Exn: EXN
-	       where type t = exn
+	       where type t = Exn.t
 structure File: FILE
 		where type AccessMode.t = File.AccessMode.t
 		where type Id.t = File.Id.t
 structure In: IN
 	      where type t = In.t
 structure Int: INT
-	       where type t = int
+	       where type t = Int.t
 structure Int16: INT
 		 where type t = Int16.t
 structure Int32: INT
-		 where type t = int
+		 where type t = Int.t
 structure Int64: INT
 		 where type t = Int64.t
 structure Int8: INT
 		where type t = Int8.t
 structure IntInf: INT_INF
-		  where type t = LargeInt.t
+		  where type t = IntInf.t
 structure IoDesc: IO_DESC
 		  where type Kind.t = IoDesc.Kind.t
 		  where type t = IoDesc.t
 structure LargeInt: INT
-		    where type t = LargeInt.t
+		    where type t = IntInf.t
 structure LargeReal: REAL
 		     where type Class.t = LargeReal.Class.t
 		     where type Format.t = LargeReal.Format.t
 		     where type RoundingMode.t = LargeReal.RoundingMode.t
-		     where type t = Real64.t
+		     where type t = Real.t
 structure LargeWord: WORD
 		     where type t = Word64.t
 structure Lazy: LAZY
@@ -105,9 +92,9 @@
 	       where type 'a Socket.Address.t = 'a Net.Socket.Address.t
 	       where type ('a, 'b, 'c) Socket.Block.t = ('a, 'b, 'c) Net.Socket.Block.t
 	       where type Socket.Desc.t = Net.Socket.Desc.t
-	       where type Socket.Option.ro = Net.Socket.Option.ro
-	       where type Socket.Option.rw = Net.Socket.Option.rw
-	       where type ('a, 'b, 'c, 'd) Socket.Option.t = ('a, 'b, 'c, 'd) Net.Socket.Option.t
+	       where type Socket.Opt.ro = Net.Socket.Opt.ro
+	       where type Socket.Opt.rw = Net.Socket.Opt.rw
+	       where type ('a, 'b, 'c, 'd) Socket.Opt.t = ('a, 'b, 'c, 'd) Net.Socket.Opt.t
 	       where type ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i) Socket.Receive.Block.t = ('a,
 											 'b,
 											 'c,
@@ -148,7 +135,7 @@
 	       where type Socket.Type.unknown = Net.Socket.Type.unknown
 	       where type ('a, 'b) Socket.sock = ('a, 'b) Net.Socket.sock
 structure Option: OPTION
-		  where type 'a t = 'a option
+		  where type 'a t = 'a Option.t
 structure Order: ORDER
 		 where type t = Order.t
 structure Out: OUT
@@ -203,7 +190,7 @@
 		where type Class.t = Real.Class.t
 		where type Format.t = Real.Format.t
 		where type RoundingMode.t = Real.RoundingMode.t
-		where type t = Real64.t
+		where type t = Real.t
 structure Real32: PACKABLE_REAL
 		  where type Class.t = Real32.Class.t
 		  where type Format.t = Real32.Format.t
@@ -213,13 +200,13 @@
 		  where type Class.t = Real64.Class.t
 		  where type Format.t = Real64.Format.t
 		  where type RoundingMode.t = Real64.RoundingMode.t
-		  where type t = Real64.t
+		  where type t = Real.t
 structure Ref: REF
 structure Scanner: SCANNER
 		   where type 'a t = 'a Scanner.t
 structure Seq: SEQ
 	       where type 'a elem = 'a
-	       where type 'a t = 'a seq
+	       where type 'a t = 'a Seq.t
 	       where type 'a unfold = unit
 	       where type 'a unfoldR = 'a
 structure String: STRING
@@ -228,27 +215,31 @@
 		  where type 'a unfoldR = 'a
 structure Substring: SUBSTRING
 		     where type 'a base = 'a Substring.base
-		     where type t = char VectorSlice.t
+		     where type t = Char.t VectorSlice.t
 structure SysError: SYS_ERROR
 		    where type Exn.t = SysError.Exn.t
 		    where type t = SysError.t
 structure Time: TIME
 		where type t = Time.t
+structure Unit:
+   sig
+      eqtype t = unit
+   end
 structure Vector: VECTOR
 		  where type 'a elem = 'a
-		  where type 'a t = 'a vector
+		  where type 'a t = 'a VectorSlice.base
 		  where type 'a unfold = 'a
 		  where type 'a unfoldR = 'a
 structure VectorSlice: VECTOR_SLICE
-		       where type 'a base = 'a vector
+		       where type 'a base = 'a VectorSlice.base
 		       where type 'a elem = 'a
 		       where type 'a t = 'a VectorSlice.t
 structure Word: WORD
-		where type t = word
+		where type t = Word.t
 structure Word16: WORD
 		  where type t = Word16.t
 structure Word32: PACKABLE_WORD
-		  where type t = word
+		  where type t = Word.t
 structure Word64: WORD
 		  where type t = Word64.t
 structure Word8: WORD8
@@ -260,33 +251,33 @@
       type 'a t0 = 'a ?.t
       type 'a unfold = 'a ?.unfold
       type 'a unfoldR = 'a ?.unfoldR
-      val all: ('a ?.t * ('a ?.elem -> bool)) -> bool
+      val all: ('a ?.t * ('a ?.elem -> Bool.t)) -> Bool.t
       val append: ('a ?.t * 'a ?.t) -> 'a ?.t
-      val concat: 'a ?.t seq -> 'a ?.t
+      val concat: 'a ?.t Seq.t -> 'a ?.t
       val cons: ('a ?.elem * 'a ?.t) -> 'a ?.t
-      val drop: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val dropPrefix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val dropPrefixN: ('a ?.t * int) -> 'a ?.t
-      val dropSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val dropSuffixN: ('a ?.t * int) -> 'a ?.t
+      val drop: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val dropPrefix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val dropPrefixN: ('a ?.t * Int.t) -> 'a ?.t
+      val dropSuffix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val dropSuffixN: ('a ?.t * Int.t) -> 'a ?.t
       val empty: unit -> 'a ?.t
-      val exists: ('a ?.t * ('a ?.elem -> bool)) -> bool
-      val fields: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t seq
-      val find: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.elem option
+      val exists: ('a ?.t * ('a ?.elem -> Bool.t)) -> Bool.t
+      val fields: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t Seq.t
+      val find: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.elem Option.t
       val fold: ('a ?.t * 'b * (('a ?.elem * 'b) -> 'b)) -> 'b
       val for: ('a ?.t * ('a ?.elem -> unit)) -> unit
-      val isEmpty: 'a ?.t -> bool
-      val join: ('a ?.t seq * 'a ?.t) -> 'a ?.t
-      val keep: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val keepPrefix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val keepPrefixN: ('a ?.t * int) -> 'a ?.t
-      val keepSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val keepSuffixN: ('a ?.t * int) -> 'a ?.t
+      val isEmpty: 'a ?.t -> Bool.t
+      val join: ('a ?.t Seq.t * 'a ?.t) -> 'a ?.t
+      val keep: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val keepPrefix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val keepPrefixN: ('a ?.t * Int.t) -> 'a ?.t
+      val keepSuffix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val keepSuffixN: ('a ?.t * Int.t) -> 'a ?.t
       val last: 'a ?.t -> 'a ?.elem
-      val make: (int * 'a) -> 'a ?.t
+      val make: (Int.t * 'a) -> 'a ?.t
       val map: ('a ?.t * ('a ?.elem -> 'b ?.elem)) -> 'b ?.t
-      val ofSeq: 'a ?.elem seq -> 'a ?.t
-      val ofSeqN: ('a ?.elem seq * int) -> 'a ?.t
+      val ofSeq: 'a ?.elem Seq.t -> 'a ?.t
+      val ofSeqN: ('a ?.elem Seq.t * Int.t) -> 'a ?.t
       val recur: ('a ?.t
 		  * 'b
 		  * ('b -> 'c)
@@ -295,28 +286,28 @@
       val reverse: 'a ?.t -> 'a ?.t
       val separate: ('a ?.t * 'a ?.elem) -> 'a ?.t
       val single: 'a ?.elem -> 'a ?.t
-      val size: 'a ?.t -> int
-      val splitPrefix: ('a ?.t * ('a ?.elem -> bool)) -> ('a ?.t * 'a ?.t)
-      val sub: ('a ?.t * int) -> 'a ?.elem
-      val tabulate: (int * (int -> 'a ?.elem)) -> 'a ?.t
-      val toSeq: 'a ?.t -> 'a ?.elem seq
-      val toSeqR: 'a ?.t -> 'a ?.elem seq
-      val tokens: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t seq
-      val unfold: ('a * ('a -> ('b ?.elem * 'a) option))
+      val size: 'a ?.t -> Int.t
+      val splitPrefix: ('a ?.t * ('a ?.elem -> Bool.t)) -> ('a ?.t * 'a ?.t)
+      val sub: ('a ?.t * Int.t) -> 'a ?.elem
+      val tabulate: (Int.t * (Int.t -> 'a ?.elem)) -> 'a ?.t
+      val toSeq: 'a ?.t -> 'a ?.elem Seq.t
+      val toSeqR: 'a ?.t -> 'a ?.elem Seq.t
+      val tokens: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t Seq.t
+      val unfold: ('a * ('a -> ('b ?.elem * 'a) Option.t))
 		  -> ('b ?.t * 'a ?.unfold)
-      val unfoldN: (int * 'a * ((int * 'a) -> ('b ?.elem * 'a) option))
+      val unfoldN: (Int.t * 'a * ((Int.t * 'a) -> ('b ?.elem * 'a) Option.t))
 		   -> ('b ?.t * 'a ?.unfold)
-      val unfoldNR: (int * 'a * ((int * 'a) -> ('b ?.elem * 'a) option))
+      val unfoldNR: (Int.t * 'a * ((Int.t * 'a) -> ('b ?.elem * 'a) Option.t))
 		    -> ('b ?.t * 'a ?.unfoldR)
-      val unfoldR: ('a * ('a -> ('b ?.elem * 'a) option))
+      val unfoldR: ('a * ('a -> ('b ?.elem * 'a) Option.t))
 		   -> ('b ?.t * 'a ?.unfoldR)
-      val update: ('a ?.t * int * 'a) -> unit
-      val updates: ('a ?.t * int * 'a seq) -> unit
+      val update: ('a ?.t * Int.t * 'a) -> unit
+      val updates: ('a ?.t * Int.t * 'a Seq.t) -> unit
       structure Unsafe:
 	 sig
-	    val make: int -> 'a ?.t
-	    val sub: ('a ?.t * int) -> 'a
-	    val update: ('a ?.t * int * 'a) -> unit
+	    val make: Int.t -> 'a ?.t
+	    val sub: ('a ?.t * Int.t) -> 'a
+	    val update: ('a ?.t * Int.t * 'a) -> unit
 	 end
    end
 signature ARRAY_SLICE = 
@@ -325,24 +316,24 @@
       type 'a elem = 'a ?.elem
       type 'a t = 'a ?.t
       type 'a t0 = 'a ?.t
-      val all: ('a ?.t * ('a ?.elem -> bool)) -> bool
-      val base: 'a ?.t -> ('a ?.base * {start: int})
-      val dropPrefix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val dropPrefixN: ('a ?.t * int) -> 'a ?.t
-      val dropSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val dropSuffixN: ('a ?.t * int) -> 'a ?.t
-      val exists: ('a ?.t * ('a ?.elem -> bool)) -> bool
-      val fields: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t seq
-      val find: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.elem option
+      val all: ('a ?.t * ('a ?.elem -> Bool.t)) -> Bool.t
+      val base: 'a ?.t -> ('a ?.base * {start: Int.t})
+      val dropPrefix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val dropPrefixN: ('a ?.t * Int.t) -> 'a ?.t
+      val dropSuffix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val dropSuffixN: ('a ?.t * Int.t) -> 'a ?.t
+      val exists: ('a ?.t * ('a ?.elem -> Bool.t)) -> Bool.t
+      val fields: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t Seq.t
+      val find: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.elem Option.t
       val fold: ('a ?.t * 'b * (('a ?.elem * 'b) -> 'b)) -> 'b
       val for: ('a ?.t * ('a ?.elem -> unit)) -> unit
       val full: 'a ?.base -> 'a ?.t
-      val get: 'a ?.t -> ('a ?.elem * 'a ?.t) option
-      val isEmpty: 'a ?.t -> bool
-      val keepPrefix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val keepPrefixN: ('a ?.t * int) -> 'a ?.t
-      val keepSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
-      val keepSuffixN: ('a ?.t * int) -> 'a ?.t
+      val get: 'a ?.t -> ('a ?.elem * 'a ?.t) Option.t
+      val isEmpty: 'a ?.t -> Bool.t
+      val keepPrefix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val keepPrefixN: ('a ?.t * Int.t) -> 'a ?.t
+      val keepSuffix: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t
+      val keepSuffixN: ('a ?.t * Int.t) -> 'a ?.t
       val last: 'a ?.t -> 'a ?.elem
       val map: ('a ?.t * ('a ?.elem -> 'b ?.elem)) -> 'b ?.base
       val recur: ('a ?.t
@@ -350,80 +341,80 @@
 		  * ('b -> 'c)
 		  * (('a ?.elem * 'b * ('b -> 'c)) -> 'c))
 		 -> 'c
-      val size: 'a ?.t -> int
-      val slice: ('a ?.t * {size: int, start: int}) -> 'a ?.t
-      val splitPrefix: ('a ?.t * ('a ?.elem -> bool)) -> ('a ?.t * 'a ?.t)
-      val sub: ('a ?.t * int) -> 'a ?.elem
-      val toSeq: 'a ?.t -> 'a ?.elem seq
-      val toSeqR: 'a ?.t -> 'a ?.elem seq
-      val tokens: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t seq
+      val size: 'a ?.t -> Int.t
+      val slice: ('a ?.t * {size: Int.t, start: Int.t}) -> 'a ?.t
+      val splitPrefix: ('a ?.t * ('a ?.elem -> Bool.t)) -> ('a ?.t * 'a ?.t)
+      val sub: ('a ?.t * Int.t) -> 'a ?.elem
+      val toSeq: 'a ?.t -> 'a ?.elem Seq.t
+      val toSeqR: 'a ?.t -> 'a ?.elem Seq.t
+      val tokens: ('a ?.t * ('a ?.elem -> Bool.t)) -> 'a ?.t Seq.t
    end
 signature BOOL = 
    sig
-      datatype t = false | true
-      val not: bool -> bool
+      eqtype t = Bool.t
+      val not: Bool.t -> Bool.t
    end
 signature CHAR = 
    sig
       type t = ?.t
-      val < : (?.t * ?.t) -> bool
-      val <= : (?.t * ?.t) -> bool
-      val == : (?.t * ?.t) -> bool
-      val > : (?.t * ?.t) -> bool
-      val >= : (?.t * ?.t) -> bool
-      val compare: (?.t * ?.t) -> order
-      val isAlpha: ?.t -> bool
-      val isAlphaNum: ?.t -> bool
-      val isAscii: ?.t -> bool
-      val isCntrl: ?.t -> bool
-      val isDigit: ?.t -> bool
-      val isGraph: ?.t -> bool
-      val isHexDigit: ?.t -> bool
-      val isLower: ?.t -> bool
-      val isPrint: ?.t -> bool
-      val isPunct: ?.t -> bool
-      val isSpace: ?.t -> bool
-      val isUpper: ?.t -> bool
-      val ofInt: int -> ?.t
-      val toInt: ?.t -> int
+      val < : (?.t * ?.t) -> Bool.t
+      val <= : (?.t * ?.t) -> Bool.t
+      val == : (?.t * ?.t) -> Bool.t
+      val > : (?.t * ?.t) -> Bool.t
+      val >= : (?.t * ?.t) -> Bool.t
+      val compare: (?.t * ?.t) -> ?.Order.t
+      val isAlpha: ?.t -> Bool.t
+      val isAlphaNum: ?.t -> Bool.t
+      val isAscii: ?.t -> Bool.t
+      val isCntrl: ?.t -> Bool.t
+      val isDigit: ?.t -> Bool.t
+      val isGraph: ?.t -> Bool.t
+      val isHexDigit: ?.t -> Bool.t
+      val isLower: ?.t -> Bool.t
+      val isPrint: ?.t -> Bool.t
+      val isPunct: ?.t -> Bool.t
+      val isSpace: ?.t -> Bool.t
+      val isUpper: ?.t -> Bool.t
+      val ofInt: Int.t -> ?.t
+      val toInt: ?.t -> Int.t
       val toLower: ?.t -> ?.t
       val toUpper: ?.t -> ?.t
       val toWord8: ?.t -> Word8.t
    end
 signature COMMAND_LINE = 
    sig
-      val arguments: unit -> string list
+      val arguments: unit -> string List.t
       val name: unit -> string
    end
 signature DATE = 
    sig
       type t = ?.t
       val format: (?.t * string) -> string
-      val hour: ?.t -> int
-      val isDst: ?.t -> bool option
+      val hour: ?.t -> Int.t
+      val isDst: ?.t -> Bool.t Option.t
       val localOffset: unit -> Time.t
-      val make: {hour: int,
-		 minute: int,
+      val make: {hour: Int.t,
+		 minute: Int.t,
 		 month: ?.Month.t,
-		 monthDay: int,
-		 offset: Time.t option,
-		 second: int,
-		 year: int}
+		 monthDay: Int.t,
+		 offset: Time.t Option.t,
+		 second: Int.t,
+		 year: Int.t}
 		-> ?.t
-      val minute: ?.t -> int
+      val minute: ?.t -> Int.t
       val month: ?.t -> ?.Month.t
-      val monthDay: ?.t -> int
-      val ofString: string -> ?.t option
+      val monthDay: ?.t -> Int.t
+      val ofString: string -> ?.t Option.t
       val ofTimeLocal: Time.t -> ?.t
       val ofTimeUniv: Time.t -> ?.t
-      val offset: ?.t -> Time.t option
-      val scanner: char seq -> (?.t * char seq) option
-      val second: ?.t -> int
+      val offset: ?.t -> Time.t Option.t
+      val scanner: Char.t Seq.t -> (?.t * Char.t Seq.t) Option.t
+      val second: ?.t -> Int.t
       val toString: ?.t -> string
       val toTime: ?.t -> Time.t
       val weekDay: ?.t -> ?.WeekDay.t
-      val year: ?.t -> int
-      val yearDay: ?.t -> int
+      val year: ?.t -> Int.t
+      val yearDay: ?.t -> Int.t
       structure Month:
 	 sig
 	    type t = ?.Month.t
@@ -464,7 +455,7 @@
 	 sig
 	    type t = ?.Stream.t
 	    val close: ?.Stream.t -> unit
-	    val read: ?.Stream.t -> string option
+	    val read: ?.Stream.t -> string Option.t
 	    val rewind: ?.Stream.t -> unit
 	 end
    end
@@ -481,7 +472,7 @@
 signature FILE = 
    sig
       eqtype t = string
-      val canAccess: (string * ?.AccessMode.t list) -> bool
+      val canAccess: (string * ?.AccessMode.t List.t) -> Bool.t
       val id: string -> ?.Id.t
       val modTime: string -> Time.t
       val openIn: string -> In.t
@@ -503,19 +494,19 @@
       structure Id:
 	 sig
 	    type t = ?.Id.t
-	    val == : (?.Id.t * ?.Id.t) -> bool
-	    val compare: (?.Id.t * ?.Id.t) -> order
-	    val hash: ?.Id.t -> word
+	    val == : (?.Id.t * ?.Id.t) -> Bool.t
+	    val compare: (?.Id.t * ?.Id.t) -> ?.Order.t
+	    val hash: ?.Id.t -> Word.t
 	 end
    end
 signature IN = 
    sig
       type t = ?.t
       val close: ?.t -> unit
-      val get1: ?.t -> char option
+      val get1: ?.t -> Char.t Option.t
       val getAll: ?.t -> string
-      val getLine: ?.t -> string option
-      val lines: ?.t -> string seq
+      val getLine: ?.t -> string Option.t
+      val lines: ?.t -> string Seq.t
       val standard: ?.t
    end
 signature INT = 
@@ -524,28 +515,28 @@
       val * : (?.t * ?.t) -> ?.t
       val + : (?.t * ?.t) -> ?.t
       val - : (?.t * ?.t) -> ?.t
-      val < : (?.t * ?.t) -> bool
-      val <= : (?.t * ?.t) -> bool
-      val == : (?.t * ?.t) -> bool
-      val > : (?.t * ?.t) -> bool
-      val >= : (?.t * ?.t) -> bool
-      val compare: (?.t * ?.t) -> order
+      val < : (?.t * ?.t) -> Bool.t
+      val <= : (?.t * ?.t) -> Bool.t
+      val == : (?.t * ?.t) -> Bool.t
+      val > : (?.t * ?.t) -> Bool.t
+      val >= : (?.t * ?.t) -> Bool.t
+      val compare: (?.t * ?.t) -> ?.Order.t
       val div: (?.t * ?.t) -> ?.t
       val fold: (?.t * ?.t * 'a * ((?.t * 'a) -> 'a)) -> 'a
       val foldDown: (?.t * ?.t * 'a * ((?.t * 'a) -> 'a)) -> 'a
       val for: (?.t * ?.t * (?.t -> unit)) -> unit
-      val fromTo: (?.t * ?.t) -> ?.t seq
-      val fromToBy: (?.t * ?.t * ?.t) -> ?.t seq
-      val geu: (?.t * ?.t) -> bool
+      val fromTo: (?.t * ?.t) -> ?.t Seq.t
+      val fromToBy: (?.t * ?.t * ?.t) -> ?.t Seq.t
+      val geu: (?.t * ?.t) -> Bool.t
       val mod: (?.t * ?.t) -> ?.t
-      val ofString: string -> ?.t option
-      val ofStringRadix: (string * Radix.t) -> ?.t option
+      val ofString: string -> ?.t Option.t
+      val ofStringRadix: (string * Radix.t) -> ?.t Option.t
       val quot: (?.t * ?.t) -> ?.t
       val rem: (?.t * ?.t) -> ?.t
-      val scanner: Radix.t -> (char seq -> (?.t * char seq) option)
+      val scanner: Radix.t -> (Char.t Seq.t -> (?.t * Char.t Seq.t) Option.t)
       val toString: ?.t -> string
       val toStringRadix: (?.t * Radix.t) -> string
-      val toWord: ?.t -> word
+      val toWord: ?.t -> Word.t
    end
 signature INT_INF = 
    sig
@@ -553,38 +544,38 @@
       val * : (?.t * ?.t) -> ?.t
       val + : (?.t * ?.t) -> ?.t
       val - : (?.t * ?.t) -> ?.t
-      val < : (?.t * ?.t) -> bool
-      val <= : (?.t * ?.t) -> bool
-      val == : (?.t * ?.t) -> bool
-      val > : (?.t * ?.t) -> bool
-      val >= : (?.t * ?.t) -> bool
-      val compare: (?.t * ?.t) -> order
+      val < : (?.t * ?.t) -> Bool.t
+      val <= : (?.t * ?.t) -> Bool.t
+      val == : (?.t * ?.t) -> Bool.t
+      val > : (?.t * ?.t) -> Bool.t
+      val >= : (?.t * ?.t) -> Bool.t
+      val compare: (?.t * ?.t) -> ?.Order.t
       val div: (?.t * ?.t) -> ?.t
       val fold: (?.t * ?.t * 'a * ((?.t * 'a) -> 'a)) -> 'a
       val foldDown: (?.t * ?.t * 'a * ((?.t * 'a) -> 'a)) -> 'a
       val for: (?.t * ?.t * (?.t -> unit)) -> unit
-      val fromTo: (?.t * ?.t) -> ?.t seq
-      val fromToBy: (?.t * ?.t * ?.t) -> ?.t seq
-      val geu: (?.t * ?.t) -> bool
+      val fromTo: (?.t * ?.t) -> ?.t Seq.t
+      val fromToBy: (?.t * ?.t * ?.t) -> ?.t Seq.t
+      val geu: (?.t * ?.t) -> Bool.t
       val mod: (?.t * ?.t) -> ?.t
-      val ofString: string -> ?.t option
-      val ofStringRadix: (string * Radix.t) -> ?.t option
+      val ofString: string -> ?.t Option.t
+      val ofStringRadix: (string * Radix.t) -> ?.t Option.t
       val quot: (?.t * ?.t) -> ?.t
       val rem: (?.t * ?.t) -> ?.t
-      val scanner: Radix.t -> (char seq -> (?.t * char seq) option)
+      val scanner: Radix.t -> (Char.t Seq.t -> (?.t * Char.t Seq.t) Option.t)
       val toString: ?.t -> string
       val toStringRadix: (?.t * Radix.t) -> string
-      val toWord: ?.t -> word
+      val toWord: ?.t -> Word.t
    end
 signature IO_DESC = 
    sig
       type t = ?.t
-      val compare: (?.t * ?.t) -> order
-      val hash: ?.t -> word
+      val compare: (?.t * ?.t) -> ?.Order.t
+      val hash: ?.t -> Word.t
       structure Kind:
 	 sig
 	    type t = ?.Kind.t
-	    val == : (?.Kind.t * ?.Kind.t) -> bool
+	    val == : (?.Kind.t * ?.Kind.t) -> Bool.t
 	    val device: ?.Kind.t
 	    val dir: ?.Kind.t
 	    val file: ?.Kind.t
@@ -601,59 +592,60 @@
 signature LIST = 
    sig
       type 'a elem = 'a ?.elem
-      datatype 'a t = nil | :: of 'a * 'a list
-      eqtype 'a t0 = 'a list
+      datatype 'a t = nil | :: of 'a * 'a List.t
+      eqtype 'a t0 = 'a List.t
       type 'a unfold = 'a ?.unfold
       type 'a unfoldR = 'a ?.unfoldR
-      val all: ('a list * ('a ?.elem -> bool)) -> bool
-      val append: ('a list * 'a list) -> 'a list
-      val concat: 'a list seq -> 'a list
-      val cons: ('a ?.elem * 'a list) -> 'a list
-      val drop: ('a list * ('a ?.elem -> bool)) -> 'a list
-      val dropPrefix: ('a list * ('a ?.elem -> bool)) -> 'a list
-      val dropPrefixN: ('a list * int) -> 'a list
-      val dropSuffix: ('a list * ('a ?.elem -> bool)) -> 'a list
-      val dropSuffixN: ('a list * int) -> 'a list
-      val empty: unit -> 'a list
-      val exists: ('a list * ('a ?.elem -> bool)) -> bool
-      val fields: ('a list * ('a ?.elem -> bool)) -> 'a list seq
-      val find: ('a list * ('a ?.elem -> bool)) -> 'a ?.elem option
-      val fold: ('a list * 'b * (('a ?.elem * 'b) -> 'b)) -> 'b
-      val for: ('a list * ('a ?.elem -> unit)) -> unit
-      val isEmpty: 'a list -> bool
-      val join: ('a list seq * 'a list) -> 'a list
-      val keep: ('a list * ('a ?.elem -> bool)) -> 'a list
-      val keepPrefix: ('a list * ('a ?.elem -> bool)) -> 'a list
-      val keepPrefixN: ('a list * int) -> 'a list
-      val keepSuffix: ('a list * ('a ?.elem -> bool)) -> 'a list
-      val keepSuffixN: ('a list * int) -> 'a list
-      val last: 'a list -> 'a ?.elem
-      val map: ('a list * ('a ?.elem -> 'b ?.elem)) -> 'b list
-      val ofSeq: 'a ?.elem seq -> 'a list
-      val ofSeqN: ('a ?.elem seq * int) -> 'a list
-      val recur: ('a list
+      val all: ('a List.t * ('a ?.elem -> Bool.t)) -> Bool.t
+      val append: ('a List.t * 'a List.t) -> 'a List.t
+      val concat: 'a List.t Seq.t -> 'a List.t
+      val cons: ('a ?.elem * 'a List.t) -> 'a List.t
+      val drop: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t
+      val dropPrefix: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t
+      val dropPrefixN: ('a List.t * Int.t) -> 'a List.t
+      val dropSuffix: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t
+      val dropSuffixN: ('a List.t * Int.t) -> 'a List.t
+      val empty: unit -> 'a List.t
+      val exists: ('a List.t * ('a ?.elem -> Bool.t)) -> Bool.t
+      val fields: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t Seq.t
+      val find: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a ?.elem Option.t
+      val fold: ('a List.t * 'b * (('a ?.elem * 'b) -> 'b)) -> 'b
+      val for: ('a List.t * ('a ?.elem -> unit)) -> unit
+      val isEmpty: 'a List.t -> Bool.t
+      val join: ('a List.t Seq.t * 'a List.t) -> 'a List.t
+      val keep: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t
+      val keepPrefix: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t
+      val keepPrefixN: ('a List.t * Int.t) -> 'a List.t
+      val keepSuffix: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t
+      val keepSuffixN: ('a List.t * Int.t) -> 'a List.t
+      val last: 'a List.t -> 'a ?.elem
+      val map: ('a List.t * ('a ?.elem -> 'b ?.elem)) -> 'b List.t
+      val ofSeq: 'a ?.elem Seq.t -> 'a List.t
+      val ofSeqN: ('a ?.elem Seq.t * Int.t) -> 'a List.t
+      val recur: ('a List.t
 		  * 'b
 		  * ('b -> 'c)
 		  * (('a ?.elem * 'b * ('b -> 'c)) -> 'c))
 		 -> 'c
-      val reverse: 'a list -> 'a list
-      val separate: ('a list * 'a ?.elem) -> 'a list
-      val single: 'a ?.elem -> 'a list
-      val size: 'a list -> int
-      val splitPrefix: ('a list * ('a ?.elem -> bool)) -> ('a list * 'a list)
-      val sub: ('a list * int) -> 'a ?.elem
-      val tabulate: (int * (int -> 'a ?.elem)) -> 'a list
-      val toSeq: 'a list -> 'a ?.elem seq
-      val toSeqR: 'a list -> 'a ?.elem seq
-      val tokens: ('a list * ('a ?.elem -> bool)) -> 'a list seq
-      val unfold: ('a * ('a -> ('b ?.elem * 'a) option))
-		  -> ('b list * 'a ?.unfold)
-      val unfoldN: (int * 'a * ((int * 'a) -> ('b ?.elem * 'a) option))
-		   -> ('b list * 'a ?.unfold)
-      val unfoldNR: (int * 'a * ((int * 'a) -> ('b ?.elem * 'a) option))
-		    -> ('b list * 'a ?.unfoldR)
-      val unfoldR: ('a * ('a -> ('b ?.elem * 'a) option))
-		   -> ('b list * 'a ?.unfoldR)
+      val reverse: 'a List.t -> 'a List.t
+      val separate: ('a List.t * 'a ?.elem) -> 'a List.t
+      val single: 'a ?.elem -> 'a List.t
+      val size: 'a List.t -> Int.t
+      val splitPrefix: ('a List.t * ('a ?.elem -> Bool.t))
+		       -> ('a List.t * 'a List.t)
+      val sub: ('a List.t * Int.t) -> 'a ?.elem
+      val tabulate: (Int.t * (Int.t -> 'a ?.elem)) -> 'a List.t
+      val toSeq: 'a List.t -> 'a ?.elem Seq.t
+      val toSeqR: 'a List.t -> 'a ?.elem Seq.t
+      val tokens: ('a List.t * ('a ?.elem -> Bool.t)) -> 'a List.t Seq.t
+      val unfold: ('a * ('a -> ('b ?.elem * 'a) Option.t))
+		  -> ('b List.t * 'a ?.unfold)
+      val unfoldN: (Int.t * 'a * ((Int.t * 'a) -> ('b ?.elem * 'a) Option.t))
+		   -> ('b List.t * 'a ?.unfold)
+      val unfoldNR: (Int.t * 'a * ((Int.t * 'a) -> ('b ?.elem * 'a) Option.t))
+		    -> ('b List.t * 'a ?.unfoldR)
+      val unfoldR: ('a * ('a -> ('b ?.elem * 'a) Option.t))
+		   -> ('b List.t * 'a ?.unfoldR)
    end
 signature NET = 
    sig
@@ -664,11 +656,11 @@
 	    type 'a t = 'a ?.Family.t
 	    type unix = ?.Family.unix
 	    type unknown = ?.Family.unknown
-	    val == : ('a ?.Family.t * 'a ?.Family.t) -> bool
+	    val == : ('a ?.Family.t * 'a ?.Family.t) -> Bool.t
 	    val all: unit
-		     -> (?.Family.unknown ?.Family.t * {name: string}) vector
+		     -> (?.Family.unknown ?.Family.t * {name: string}) VectorSlice.base
 	    val inet: ?.Family.inet ?.Family.t
-	    val ofString: string -> ?.Family.unknown ?.Family.t option
+	    val ofString: string -> ?.Family.unknown ?.Family.t Option.t
 	    val toString: 'a ?.Family.t -> string
 	    val unix: ?.Family.unix ?.Family.t
 	 end
@@ -676,38 +668,39 @@
 	 sig
 	    type t = ?.Host.t
 	    val address: ?.Host.t -> ?.Host.Address.t
-	    val addresses: ?.Host.t -> ?.Host.Address.t vector
-	    val aliases: ?.Host.t -> string vector
+	    val addresses: ?.Host.t -> ?.Host.Address.t VectorSlice.base
+	    val aliases: ?.Host.t -> string VectorSlice.base
 	    val family: ?.Host.t -> ?.Family.unknown ?.Family.t
-	    val getByAddress: ?.Host.Address.t -> ?.Host.t option
-	    val getByName: string -> ?.Host.t option
+	    val getByAddress: ?.Host.Address.t -> ?.Host.t Option.t
+	    val getByName: string -> ?.Host.t Option.t
 	    val name: ?.Host.t -> string
 	    structure Address:
 	       sig
 		  type t = ?.Host.Address.t
-		  val == : (?.Host.Address.t * ?.Host.Address.t) -> bool
-		  val ofString: string -> ?.Host.Address.t option
-		  val scanner: char seq -> (?.Host.Address.t * char seq) option
+		  val == : (?.Host.Address.t * ?.Host.Address.t) -> Bool.t
+		  val ofString: string -> ?.Host.Address.t Option.t
+		  val scanner: Char.t Seq.t
+			       -> (?.Host.Address.t * Char.t Seq.t) Option.t
 		  val toString: ?.Host.Address.t -> string
 	       end
 	 end
       structure Protocol:
 	 sig
 	    type t = ?.Protocol.t
-	    val aliases: ?.Protocol.t -> string vector
-	    val getByName: string -> ?.Protocol.t option
-	    val getByNumber: int -> ?.Protocol.t option
+	    val aliases: ?.Protocol.t -> string VectorSlice.base
+	    val getByName: string -> ?.Protocol.t Option.t
+	    val getByNumber: Int.t -> ?.Protocol.t Option.t
 	    val name: ?.Protocol.t -> string
-	    val number: ?.Protocol.t -> int
+	    val number: ?.Protocol.t -> Int.t
 	 end
       structure Service:
 	 sig
 	    type t = ?.Service.t
-	    val aliases: ?.Service.t -> string vector
-	    val getByName: (string * string option) -> ?.Service.t option
-	    val getByPort: (int * string option) -> ?.Service.t option
+	    val aliases: ?.Service.t -> string VectorSlice.base
+	    val getByName: (string * string Option.t) -> ?.Service.t Option.t
+	    val getByPort: (Int.t * string Option.t) -> ?.Service.t Option.t
 	    val name: ?.Service.t -> string
-	    val port: ?.Service.t -> int
+	    val port: ?.Service.t -> Int.t
 	    val protocol: ?.Service.t -> string
 	 end
       structure Socket:
@@ -718,44 +711,44 @@
 			 * ((('a, ?.Socket.Type.active ?.Socket.Type.stream) ?.Socket.sock
 			     * 'a ?.Socket.Address.t),
 			    (('a, ?.Socket.Type.active ?.Socket.Type.stream) ?.Socket.sock
-			     * 'a ?.Socket.Address.t) option,
+			     * 'a ?.Socket.Address.t) Option.t,
 			    'b) ?.Socket.Block.t)
 			-> 'b
 	    val bind: (('a, 'b) ?.Socket.sock * 'a ?.Socket.Address.t) -> unit
 	    val close: ('a, 'b) ?.Socket.sock -> unit
 	    val connect: (('a, 'b) ?.Socket.sock
 			  * 'a ?.Socket.Address.t
-			  * (unit, unit option, 'c) ?.Socket.Block.t)
+			  * (unit, unit Option.t, 'c) ?.Socket.Block.t)
 			 -> 'c
 	    val desc: ('a, 'b) ?.Socket.sock -> ?.Socket.Desc.t
-	    val getOption: (('a, 'b) ?.Socket.sock
-			    * ('c, 'a, 'b, 'd) ?.Socket.Option.t)
-			   -> 'c
-	    val ioDesc: ('a, 'b) ?.Socket.sock -> int
+	    val getOpt: (('a, 'b) ?.Socket.sock
+			 * ('c, 'a, 'b, 'd) ?.Socket.Opt.t)
+			-> 'c
+	    val ioDesc: ('a, 'b) ?.Socket.sock -> Int.t
 	    val listen: (('a, ?.Socket.Type.passive ?.Socket.Type.stream) ?.Socket.sock
-			 * int)
+			 * Int.t)
 			-> unit
 	    val make: ('a ?.Family.t
 		       * 'b ?.Socket.Type.t
-		       * {protocol: int} option)
+		       * {protocol: Int.t} Option.t)
 		      -> ('a, 'b) ?.Socket.sock
 	    val makePair: ('a ?.Family.t
 			   * 'b ?.Socket.Type.t
-			   * {protocol: int} option)
+			   * {protocol: Int.t} Option.t)
 			  -> (('a, 'b) ?.Socket.sock * ('a, 'b) ?.Socket.sock)
 	    val myAddress: ('a, 'b) ?.Socket.sock -> 'a ?.Socket.Address.t
 	    val peerAddress: ('a, 'b) ?.Socket.sock -> 'a ?.Socket.Address.t
-	    val select: {exs: ?.Socket.Desc.t list,
-			 rds: ?.Socket.Desc.t list,
-			 timeout: Time.t option,
-			 wrs: ?.Socket.Desc.t list}
-			-> {exs: ?.Socket.Desc.t list,
-			    rds: ?.Socket.Desc.t list,
-			    wrs: ?.Socket.Desc.t list}
-	    val setOption: (('a, 'b) ?.Socket.sock
-			    * ('c, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-			    * 'c)
-			   -> unit
+	    val select: {exs: ?.Socket.Desc.t List.t,
+			 rds: ?.Socket.Desc.t List.t,
+			 timeout: Time.t Option.t,
+			 wrs: ?.Socket.Desc.t List.t}
+			-> {exs: ?.Socket.Desc.t List.t,
+			    rds: ?.Socket.Desc.t List.t,
+			    wrs: ?.Socket.Desc.t List.t}
+	    val setOpt: (('a, 'b) ?.Socket.sock
+			 * ('c, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+			 * 'c)
+			-> unit
 	    val shutdown: (('a, 'b ?.Socket.Type.stream) ?.Socket.sock
 			   * ?.Socket.ShutdownMode.t)
 			  -> unit
@@ -763,71 +756,72 @@
 	       sig
 		  type 'a t = 'a ?.Socket.Address.t
 		  val == : ('a ?.Socket.Address.t * 'a ?.Socket.Address.t)
-			   -> bool
+			   -> Bool.t
 		  val family: 'a ?.Socket.Address.t -> 'a ?.Family.t
-		  val inet: {port: int} -> ?.Family.inet ?.Socket.Address.t
-		  val ofHost: (?.Host.Address.t * {port: int})
+		  val inet: {port: Int.t} -> ?.Family.inet ?.Socket.Address.t
+		  val ofHost: (?.Host.Address.t * {port: Int.t})
 			      -> ?.Family.inet ?.Socket.Address.t
 		  val ofUnix: string -> ?.Family.unix ?.Socket.Address.t
 		  val toHost: ?.Family.inet ?.Socket.Address.t
-			      -> (?.Host.Address.t * {port: int})
+			      -> (?.Host.Address.t * {port: Int.t})
 		  val toUnix: ?.Family.unix ?.Socket.Address.t -> string
 	       end
 	    structure Block:
 	       sig
 		  type ('a, 'b, 'c) t = ('a, 'b, 'c) ?.Socket.Block.t
-		  type ('a, 'b) u = ('a, 'a option, 'b) ?.Socket.Block.t
+		  type ('a, 'b) u = ('a, 'a Option.t, 'b) ?.Socket.Block.t
 		  val may: ('a, 'b, 'a) ?.Socket.Block.t
 		  val non: ('a, 'b, 'b) ?.Socket.Block.t
 	       end
 	    structure Desc:
 	       sig
 		  type t = ?.Socket.Desc.t
-		  val == : (?.Socket.Desc.t * ?.Socket.Desc.t) -> bool
+		  val == : (?.Socket.Desc.t * ?.Socket.Desc.t) -> Bool.t
 	       end
-	    structure Option:
+	    structure Opt:
 	       sig
-		  type ro = ?.Socket.Option.ro
-		  type rw = ?.Socket.Option.rw
-		  type ('a, 'b, 'c, 'd) t = ('a, 'b, 'c, 'd) ?.Socket.Option.t
-		  val atmark: (bool,
+		  type ro = ?.Socket.Opt.ro
+		  type rw = ?.Socket.Opt.rw
+		  type ('a, 'b, 'c, 'd) t = ('a, 'b, 'c, 'd) ?.Socket.Opt.t
+		  val atmark: (Bool.t,
 			       'a,
 			       ?.Socket.Type.active ?.Socket.Type.stream,
-			       ?.Socket.Option.ro) ?.Socket.Option.t
-		  val broadcast: (bool, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val debug: (bool, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val dontRoute: (bool, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val error: (bool, 'a, 'b, ?.Socket.Option.ro) ?.Socket.Option.t
-		  val keepAlive: (bool, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val linger: (Time.t option, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val nRead: (int, 'a, 'b, ?.Socket.Option.ro) ?.Socket.Option.t
-		  val noDelay: (bool,
+			       ?.Socket.Opt.ro) ?.Socket.Opt.t
+		  val broadcast: (Bool.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val debug: (Bool.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val dontRoute: (Bool.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val error: (Bool.t, 'a, 'b, ?.Socket.Opt.ro) ?.Socket.Opt.t
+		  val keepAlive: (Bool.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val linger: (Time.t Option.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val nRead: (Int.t, 'a, 'b, ?.Socket.Opt.ro) ?.Socket.Opt.t
+		  val noDelay: (Bool.t,
 				?.Family.inet,
 				'a ?.Socket.Type.stream,
-				?.Socket.Option.rw) ?.Socket.Option.t
-		  val oobInline: (bool, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val rcvBuf: (int, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val reuseAddr: (bool, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
-		  val sndBuf: (int, 'a, 'b, ?.Socket.Option.rw) ?.Socket.Option.t
+				?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val oobInline: (Bool.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val rcvBuf: (Int.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val reuseAddr: (Bool.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
+		  val sndBuf: (Int.t, 'a, 'b, ?.Socket.Opt.rw) ?.Socket.Opt.t
 		  val ty: (?.Socket.Type.unknown ?.Socket.Type.t,
 			   'a,
 			   'b,
-			   ?.Socket.Option.ro) ?.Socket.Option.t
+			   ?.Socket.Opt.ro) ?.Socket.Opt.t
 	       end
 	    structure Receive:
 	       sig
 		  val receive: (('a, 'b, 'c, 'd) ?.Socket.Receive.From.t
 				* ('a, 'e, 'f, 'g, 'h, 'b, 'c) ?.Socket.Receive.To.t
 				* ('a,
-				   (int * 'a ?.Socket.Address.t),
-				   int,
-				   (Word8.t vector * 'a ?.Socket.Address.t),
-				   Word8.t vector,
+				   (Int.t * 'a ?.Socket.Address.t),
+				   Int.t,
+				   (Word8.t VectorSlice.base
+				    * 'a ?.Socket.Address.t),
+				   Word8.t VectorSlice.base,
 				   'e,
 				   'f,
 				   'g,
 				   'h) ?.Socket.Receive.Block.t
-				* ?.Socket.Receive.Flag.t list)
+				* ?.Socket.Receive.Flag.t List.t)
 			       -> 'd
 		  structure Block:
 		     sig
@@ -846,10 +840,10 @@
 				  'c,
 				  'd,
 				  'e,
-				  'b option,
-				  'c option,
-				  'd option,
-				  'e option) ?.Socket.Receive.Block.t
+				  'b Option.t,
+				  'c Option.t,
+				  'd Option.t,
+				  'e Option.t) ?.Socket.Receive.Block.t
 		     end
 		  structure Flag:
 		     sig
@@ -877,7 +871,7 @@
 							       'g) ?.Socket.Receive.To.t
 			val array: Word8.t ?.Sequence.Slice.t
 				   -> ('a, 'b, 'c, 'd, 'e, 'b, 'c) ?.Socket.Receive.To.t
-			val vector: {numBytes: int}
+			val vector: {numBytes: Int.t}
 				    -> ('a, 'b, 'c, 'd, 'e, 'd, 'e) ?.Socket.Receive.To.t
 		     end
 	       end
@@ -885,8 +879,8 @@
 	       sig
 		  val send: (?.Socket.Send.From.t
 			     * ('a, 'b, 'c, 'd) ?.Socket.Send.To.t
-			     * ('a, unit, int, bool, int option, 'b, 'c) ?.Socket.Send.Block.t
-			     * ?.Socket.Send.Flag.t list)
+			     * ('a, unit, Int.t, Bool.t, Int.t Option.t, 'b, 'c) ?.Socket.Send.Block.t
+			     * ?.Socket.Send.Flag.t List.t)
 			    -> 'd
 		  structure Block:
 		     sig
@@ -942,13 +936,13 @@
 		  type 'a stream = 'a ?.Socket.Type.stream
 		  type 'a t = 'a ?.Socket.Type.t
 		  type unknown = ?.Socket.Type.unknown
-		  val == : ('a ?.Socket.Type.t * 'a ?.Socket.Type.t) -> bool
+		  val == : ('a ?.Socket.Type.t * 'a ?.Socket.Type.t) -> Bool.t
 		  val all: unit
 			   -> (?.Socket.Type.unknown ?.Socket.Type.t
-			       * {name: string}) vector
+			       * {name: string}) VectorSlice.base
 		  val dgram: ?.Socket.Type.dgram ?.Socket.Type.t
 		  val ofString: string
-				-> ?.Socket.Type.unknown ?.Socket.Type.t option
+				-> ?.Socket.Type.unknown ?.Socket.Type.t Option.t
 		  val stream: 'a ?.Socket.Type.stream ?.Socket.Type.t
 		  val toString: 'a ?.Socket.Type.t -> string
 	       end
@@ -957,10 +951,10 @@
 signature OPTION = 
    sig
       datatype 'a t = None | Some of 'a
-      val isNone: 'a ?.t -> bool
-      val isSome: 'a ?.t -> bool
+      val isNone: 'a ?.t -> Bool.t
+      val isSome: 'a ?.t -> Bool.t
       val map: ('a ?.t * ('a -> 'b)) -> 'b ?.t
-      val toSeq: 'a ?.t -> 'a seq
+      val toSeq: 'a ?.t -> 'a Seq.t
       val valOf: 'a ?.t -> 'a
    end
 signature ORDER = 
@@ -975,43 +969,43 @@
       val flush: ?.t -> unit
       val newline: ?.t -> unit
       val put: (?.t * string) -> unit
-      val put1: (?.t * char) -> unit
-      val puts: (?.t * string seq) -> unit
+      val put1: (?.t * Char.t) -> unit
+      val puts: (?.t * string Seq.t) -> unit
       val standard: ?.t
    end
 signature PACKABLE_REAL = 
    sig
       type t = ?.t
-      val != : (?.t * ?.t) -> bool
+      val != : (?.t * ?.t) -> Bool.t
       val * : (?.t * ?.t) -> ?.t
       val + : (?.t * ?.t) -> ?.t
       val - : (?.t * ?.t) -> ?.t
       val / : (?.t * ?.t) -> ?.t
-      val < : (?.t * ?.t) -> bool
-      val <= : (?.t * ?.t) -> bool
-      val == : (?.t * ?.t) -> bool
-      val > : (?.t * ?.t) -> bool
-      val >= : (?.t * ?.t) -> bool
-      val ?= : (?.t * ?.t) -> bool
+      val < : (?.t * ?.t) -> Bool.t
+      val <= : (?.t * ?.t) -> Bool.t
+      val == : (?.t * ?.t) -> Bool.t
+      val > : (?.t * ?.t) -> Bool.t
+      val >= : (?.t * ?.t) -> Bool.t
+      val ?= : (?.t * ?.t) -> Bool.t
       val abs: ?.t -> ?.t
       val acos: ?.t -> ?.t
       val asin: ?.t -> ?.t
       val atan: ?.t -> ?.t
       val atan2: (?.t * ?.t) -> ?.t
-      val ceil: ?.t -> int
+      val ceil: ?.t -> Int.t
       val checkFloat: ?.t -> ?.t
       val class: ?.t -> ?.Class.t
-      val compare: (?.t * ?.t) -> order
+      val compare: (?.t * ?.t) -> ?.Order.t
       val copySign: (?.t * ?.t) -> ?.t
       val cos: ?.t -> ?.t
       val cosh: ?.t -> ?.t
       val e: ?.t
       val exp: ?.t -> ?.t
-      val floor: ?.t -> int
+      val floor: ?.t -> Int.t
       val format: (?.t * ?.Format.t) -> string
-      val isFinite: ?.t -> bool
-      val isNan: ?.t -> bool
-      val isNormal: ?.t -> bool
+      val isFinite: ?.t -> Bool.t
+      val isNan: ?.t -> Bool.t
+      val isNormal: ?.t -> Bool.t
       val ln: ?.t -> ?.t
       val log10: ?.t -> ?.t
       val max: (?.t * ?.t) -> ?.t
@@ -1021,52 +1015,55 @@
       val minPos: ?.t
       val negInf: ?.t
       val nextAfter: (?.t * ?.t) -> ?.t
-      val ofBytes: (Word8.t vector * ?.Endian.t) -> ?.t
-      val ofDecimal: {class: ?.Class.t, digits: int list, exp: int, sign: bool}
-		     -> ?.t option
-      val ofInt: int -> ?.t
-      val ofLarge: (Real64.t * ?.RoundingMode.t) -> ?.t
-      val ofLargeInt: LargeInt.t -> ?.t
-      val ofManExp: {exp: int, man: ?.t} -> ?.t
-      val ofString: string -> ?.t option
+      val ofBytes: (Word8.t VectorSlice.base * ?.Endian.t) -> ?.t
+      val ofDecimal: {class: ?.Class.t,
+		      digits: Int.t List.t,
+		      exp: Int.t,
+		      sign: Bool.t}
+		     -> ?.t Option.t
+      val ofInt: Int.t -> ?.t
+      val ofLarge: (Real.t * ?.RoundingMode.t) -> ?.t
+      val ofLargeInt: IntInf.t -> ?.t
+      val ofManExp: {exp: Int.t, man: ?.t} -> ?.t
+      val ofString: string -> ?.t Option.t
       val pi: ?.t
       val posInf: ?.t
       val pow: (?.t * ?.t) -> ?.t
-      val precision: int
-      val radix: int
+      val precision: Int.t
+      val radix: Int.t
       val realCeil: ?.t -> ?.t
       val realFloor: ?.t -> ?.t
       val realMod: ?.t -> ?.t
       val realRound: ?.t -> ?.t
       val realTrunc: ?.t -> ?.t
       val rem: (?.t * ?.t) -> ?.t
-      val round: ?.t -> int
-      val sameSign: (?.t * ?.t) -> bool
-      val scanner: char seq -> (?.t * char seq) option
-      val sign: ?.t -> int
-      val signBit: ?.t -> bool
+      val round: ?.t -> Int.t
+      val sameSign: (?.t * ?.t) -> Bool.t
+      val scanner: Char.t Seq.t -> (?.t * Char.t Seq.t) Option.t
+      val sign: ?.t -> Int.t
+      val signBit: ?.t -> Bool.t
       val sin: ?.t -> ?.t
       val sinh: ?.t -> ?.t
       val split: ?.t -> {frac: ?.t, whole: ?.t}
       val sqrt: ?.t -> ?.t
-      val subArr: (Word8.t ArraySlice.base * int * ?.Endian.t) -> ?.t
-      val subVec: (Word8.t vector * int * ?.Endian.t) -> ?.t
+      val subArr: (Word8.t ArraySlice.base * Int.t * ?.Endian.t) -> ?.t
+      val subVec: (Word8.t VectorSlice.base * Int.t * ?.Endian.t) -> ?.t
       val tan: ?.t -> ?.t
       val tanh: ?.t -> ?.t
-      val toBytes: (?.t * ?.Endian.t) -> Word8.t vector
+      val toBytes: (?.t * ?.Endian.t) -> Word8.t VectorSlice.base
       val toDecimal: ?.t
 		     -> {class: ?.Class.t,
-			 digits: int list,
-			 exp: int,
-			 sign: bool}
-      val toInt: (?.t * ?.RoundingMode.t) -> int
-      val toLarge: ?.t -> Real64.t
-      val toLargeInt: (?.t * ?.RoundingMode.t) -> LargeInt.t
-      val toManExp: ?.t -> {exp: int, man: ?.t}
+			 digits: Int.t List.t,
+			 exp: Int.t,
+			 sign: Bool.t}
+      val toInt: (?.t * ?.RoundingMode.t) -> Int.t
+      val toLarge: ?.t -> Real.t
+      val toLargeInt: (?.t * ?.RoundingMode.t) -> IntInf.t
+      val toManExp: ?.t -> {exp: Int.t, man: ?.t}
       val toString: ?.t -> string
-      val trunc: ?.t -> int
-      val unordered: (?.t * ?.t) -> bool
-      val update: (Word8.t ArraySlice.base * int * ?.t * ?.Endian.t) -> unit
+      val trunc: ?.t -> Int.t
+      val unordered: (?.t * ?.t) -> Bool.t
+      val update: (Word8.t ArraySlice.base * Int.t * ?.t * ?.Endian.t) -> unit
       val ~ : ?.t -> ?.t
       structure Class:
 	 sig
@@ -1074,31 +1071,34 @@
 	 end
       structure Decimal:
 	 sig
-	    eqtype t = {class: ?.Class.t, digits: int list, exp: int, sign: bool}
+	    eqtype t = {class: ?.Class.t,
+			digits: Int.t List.t,
+			exp: Int.t,
+			sign: Bool.t}
 	    val ofString: string
 			  -> {class: ?.Class.t,
-			      digits: int list,
-			      exp: int,
-			      sign: bool} option
-	    val scanner: char seq
+			      digits: Int.t List.t,
+			      exp: Int.t,
+			      sign: Bool.t} Option.t
+	    val scanner: Char.t Seq.t
 			 -> ({class: ?.Class.t,
-			      digits: int list,
-			      exp: int,
-			      sign: bool}
-			     * char seq) option
+			      digits: Int.t List.t,
+			      exp: Int.t,
+			      sign: Bool.t}
+			     * Char.t Seq.t) Option.t
 	    val toString: {class: ?.Class.t,
-			   digits: int list,
-			   exp: int,
-			   sign: bool}
+			   digits: Int.t List.t,
+			   exp: Int.t,
+			   sign: Bool.t}
 			  -> string
 	 end
       structure Format:
 	 sig
 	    type t = ?.Format.t
 	    val exact: ?.Format.t
-	    val fix: int -> ?.Format.t
-	    val gen: int -> ?.Format.t
-	    val sci: int -> ?.Format.t
+	    val fix: Int.t -> ?.Format.t
+	    val gen: Int.t -> ?.Format.t
+	    val sci: Int.t -> ?.Format.t
 	 end
       structure RoundingMode:
 	 sig
@@ -1117,32 +1117,32 @@
       val * : (?.t * ?.t) -> ?.t
       val + : (?.t * ?.t) -> ?.t
       val - : (?.t * ?.t) -> ?.t
-      val < : (?.t * ?.t) -> bool
-      val << : (?.t * word) -> ?.t
-      val <= : (?.t * ?.t) -> bool
-      val == : (?.t * ?.t) -> bool
-      val > : (?.t * ?.t) -> bool
-      val >= : (?.t * ?.t) -> bool
-      val >> : (?.t * word) -> ?.t
+      val < : (?.t * ?.t) -> Bool.t
+      val << : (?.t * Word.t) -> ?.t
+      val <= : (?.t * ?.t) -> Bool.t
+      val == : (?.t * ?.t) -> Bool.t
+      val > : (?.t * ?.t) -> Bool.t
+      val >= : (?.t * ?.t) -> Bool.t
+      val >> : (?.t * Word.t) -> ?.t
       val andb: (?.t * ?.t) -> ?.t
-      val compare: (?.t * ?.t) -> order
+      val compare: (?.t * ?.t) -> ?.Order.t
       val div: (?.t * ?.t) -> ?.t
       val mod: (?.t * ?.t) -> ?.t
       val notb: ?.t -> ?.t
       val ofLarge: Word64.t -> ?.t
-      val ofString: string -> ?.t option
-      val ofStringRadix: (string * Radix.t) -> ?.t option
+      val ofString: string -> ?.t Option.t
+      val ofStringRadix: (string * Radix.t) -> ?.t Option.t
       val orb: (?.t * ?.t) -> ?.t
-      val scanner: Radix.t -> (char seq -> (?.t * char seq) option)
-      val subArr: (Word8.t ArraySlice.base * int * ?.Endian.t) -> ?.t
-      val subVec: (Word8.t vector * int * ?.Endian.t) -> ?.t
+      val scanner: Radix.t -> (Char.t Seq.t -> (?.t * Char.t Seq.t) Option.t)
+      val subArr: (Word8.t ArraySlice.base * Int.t * ?.Endian.t) -> ?.t
+      val subVec: (Word8.t VectorSlice.base * Int.t * ?.Endian.t) -> ?.t
       val toLarge: ?.t -> Word64.t
       val toLargeX: ?.t -> Word64.t
       val toString: ?.t -> string
       val toStringRadix: (?.t * Radix.t) -> string
-      val update: (Word8.t ArraySlice.base * int * ?.t * ?.Endian.t) -> unit
+      val update: (Word8.t ArraySlice.base * Int.t * ?.t * ?.Endian.t) -> unit
       val xorb: (?.t * ?.t) -> ?.t
-      val ~>> : (?.t * word) -> ?.t
+      val ~>> : (?.t * Word.t) -> ?.t
    end
 signature PATH = 
    sig
@@ -1150,18 +1150,18 @@
       val append: (string * string) -> string
       val base: string -> string
       val dir: string -> string
-      val ext: string -> string option
+      val ext: string -> string Option.t
       val file: string -> string
       val full: string -> string
       val getParent: string -> string
       val getVolume: string -> string
-      val isAbsolute: string -> bool
-      val isCanonical: string -> bool
-      val isDir: string -> bool
-      val isLink: string -> bool
-      val isRelative: string -> bool
-      val isRoot: string -> bool
-      val joinBaseExt: {base: string, ext: string option} -> string
+      val isAbsolute: string -> Bool.t
+      val isCanonical: string -> Bool.t
+      val isDir: string -> Bool.t
+      val isLink: string -> Bool.t
+      val isRelative: string -> Bool.t
+      val isRoot: string -> Bool.t
+      val joinBaseExt: {base: string, ext: string Option.t} -> string
       val joinDirFile: {dir: string, file: string} -> string
       val mkAbsolute: (string * {relativeTo: string}) -> string
       val mkCanonical: string -> string
@@ -1170,7 +1170,7 @@
       val ofUnix: string -> string
       val readLink: string -> string
       val real: string -> string
-      val splitBaseExt: string -> {base: string, ext: string option}
+      val splitBaseExt: string -> {base: string, ext: string Option.t}
       val splitDirFile: string -> {dir: string, file: string}
       val toPieces: string -> ?.Pieces.t
       val toUnix: string -> string
@@ -1182,17 +1182,19 @@
 	 end
       structure Pieces:
 	 sig
-	    datatype t = T of {arcs: string list, isAbs: bool, volume: string}
+	    datatype t = T of {arcs: string List.t,
+			       isAbs: Bool.t,
+			       volume: string}
 	 end
       structure Volume:
 	 sig
 	    eqtype t = string
-	    val isValid: (string * {isAbs: bool}) -> bool
+	    val isValid: (string * {isAbs: Bool.t}) -> Bool.t
 	 end
    end
 signature POLL = 
    sig
-      val poll: (?.Desc.t list * Time.t option) -> ?.Info.t list
+      val poll: (?.Desc.t List.t * Time.t Option.t) -> ?.Info.t List.t
       structure Desc:
 	 sig
 	    type t = ?.Desc.t
@@ -1200,21 +1202,21 @@
 	    val addIn: ?.Desc.t -> ?.Desc.t
 	    val addOut: ?.Desc.t -> ?.Desc.t
 	    val addPri: ?.Desc.t -> ?.Desc.t
-	    val ofIO: int -> ?.Desc.t option
-	    val toIO: ?.Desc.t -> int
+	    val ofIO: Int.t -> ?.Desc.t Option.t
+	    val toIO: ?.Desc.t -> Int.t
 	 end
       structure Info:
 	 sig
 	    type t = ?.Info.t
-	    val isIn: ?.Info.t -> bool
-	    val isOut: ?.Info.t -> bool
-	    val isPri: ?.Info.t -> bool
+	    val isIn: ?.Info.t -> Bool.t
+	    val isOut: ?.Info.t -> Bool.t
+	    val isPri: ?.Info.t -> Bool.t
 	    val toDesc: ?.Info.t -> ?.Desc.t
 	 end
    end
 signature POSIX = 
    sig
-      val access: (string * ?.AccessMode.t list) -> bool
+      val access: (string * ?.AccessMode.t List.t) -> Bool.t
       val alarm: Time.t -> Time.t
       val cfgetispeed: ?.Termios.t -> ?.Termios.Speed.t
       val cfgetospeed: ?.Termios.t -> ?.Termios.Speed.t
@@ -1231,27 +1233,27 @@
       val ctermid: unit -> string
       val dup: ?.FileDesc.t -> ?.FileDesc.t
       val dup2: {new: ?.FileDesc.t, old: ?.FileDesc.t} -> unit
-      val environ: unit -> string list
-      val exec: (string * string list) -> 'a
-      val exece: (string * string list * string list) -> 'a
-      val execp: (string * string list) -> 'a
+      val environ: unit -> string List.t
+      val exec: (string * string List.t) -> 'a
+      val exece: (string * string List.t * string List.t) -> 'a
+      val execp: (string * string List.t) -> 'a
       val exit: Word8.t -> 'a
       val fchmod: (?.FileDesc.t * ?.Mode.t) -> unit
       val fchown: (?.FileDesc.t * ?.Uid.t * ?.Gid.t) -> unit
       val fcntl: (?.FileDesc.t * ('a, 'b) ?.Fcntl.t * 'a) -> 'b
-      val fork: unit -> ?.Pid.t option
-      val fpathconf: (?.FileDesc.t * string) -> Word64.t option
+      val fork: unit -> ?.Pid.t Option.t
+      val fpathconf: (?.FileDesc.t * string) -> Word64.t Option.t
       val fstat: ?.FileDesc.t -> ?.Stat.t
       val fsync: ?.FileDesc.t -> unit
       val ftruncate: (?.FileDesc.t * Int64.t) -> unit
       val getcwd: unit -> string
       val getegid: unit -> ?.Gid.t
-      val getenv: string -> string option
+      val getenv: string -> string Option.t
       val geteuid: unit -> ?.Uid.t
       val getgid: unit -> ?.Gid.t
       val getgrgid: ?.Gid.t -> ?.Group.t
       val getgrnam: string -> ?.Group.t
-      val getgroups: unit -> ?.Gid.t list
+      val getgroups: unit -> ?.Gid.t List.t
       val getlogin: unit -> string
       val getpgrp: unit -> ?.Pid.t
       val getpid: unit -> ?.Pid.t
@@ -1259,7 +1261,7 @@
       val getpwnam: string -> ?.Passwd.t
       val getpwuid: ?.Uid.t -> ?.Passwd.t
       val getuid: unit -> ?.Uid.t
-      val isatty: ?.FileDesc.t -> bool
+      val isatty: ?.FileDesc.t -> Bool.t
       val kill: (?.KillArg.t * ?.Signal.t) -> unit
       val link: {new: string, old: string} -> unit
       val lseek: (?.FileDesc.t * Int64.t * ?.Whence.t) -> Int64.t
@@ -1268,18 +1270,18 @@
       val mkfifo: (string * ?.Mode.t) -> unit
       val opendir: string -> ?.DirStream.t
       val openf: (string * ?.OpenMode.t * ?.OpenFlags.t) -> ?.FileDesc.t
-      val pathconf: (string * string) -> Word64.t option
+      val pathconf: (string * string) -> Word64.t Option.t
       val pause: unit -> unit
       val pipe: unit -> {infd: ?.FileDesc.t, outfd: ?.FileDesc.t}
-      val readArr: (?.FileDesc.t * Word8.t ?.Sequence.Slice.t) -> int
-      val readVec: (?.FileDesc.t * int) -> Word8.t vector
-      val readdir: ?.DirStream.t -> string option
+      val readArr: (?.FileDesc.t * Word8.t ?.Sequence.Slice.t) -> Int.t
+      val readVec: (?.FileDesc.t * Int.t) -> Word8.t VectorSlice.base
+      val readdir: ?.DirStream.t -> string Option.t
       val readlink: string -> string
       val rename: {new: string, old: string} -> unit
       val rewinddir: ?.DirStream.t -> unit
       val rmdir: string -> unit
       val setgid: ?.Gid.t -> unit
-      val setpgid: {pgid: ?.Pid.t option, pid: ?.Pid.t option} -> unit
+      val setpgid: {pgid: ?.Pid.t Option.t, pid: ?.Pid.t Option.t} -> unit
       val setsid: unit -> ?.Pid.t
       val setuid: ?.Uid.t -> unit
       val sleep: Time.t -> Time.t
@@ -1291,7 +1293,7 @@
       val tcflush: (?.FileDesc.t * ?.QueueSel.t) -> unit
       val tcgetattr: ?.FileDesc.t -> ?.Termios.t
       val tcgetpgrp: ?.FileDesc.t -> ?.Pid.t
-      val tcsendbreak: (?.FileDesc.t * int) -> unit
+      val tcsendbreak: (?.FileDesc.t * Int.t) -> unit
       val tcsetattr: (?.FileDesc.t * ?.SetAction.t * ?.Termios.t) -> unit
       val tcsetpgrp: (?.FileDesc.t * ?.Pid.t) -> unit
       val time: unit -> Time.t
@@ -1303,16 +1305,16 @@
 		     utime: Time.t}
       val ttyname: ?.FileDesc.t -> string
       val umask: ?.Mode.t -> ?.Mode.t
-      val uname: unit -> (string * string) list
+      val uname: unit -> (string * string) List.t
       val unlink: string -> unit
-      val utime: (string * {actime: Time.t, modtime: Time.t} option) -> unit
+      val utime: (string * {actime: Time.t, modtime: Time.t} Option.t) -> unit
       val wait: unit -> (?.Pid.t * ?.ExitStatus.t)
-      val waitpid: (?.WaitPidArg.t * ?.WaitPidFlags.t list)
+      val waitpid: (?.WaitPidArg.t * ?.WaitPidFlags.t List.t)
 		   -> (?.Pid.t * ?.ExitStatus.t)
-      val waitpidNohang: (?.WaitPidArg.t * ?.WaitPidFlags.t list)
-			 -> (?.Pid.t * ?.ExitStatus.t) option
-      val writeArr: (?.FileDesc.t * Word8.t ?.Sequence.Slice.t) -> int
-      val writeVec: (?.FileDesc.t * Word8.t VectorSlice.t) -> int
+      val waitpidNohang: (?.WaitPidArg.t * ?.WaitPidFlags.t List.t)
+			 -> (?.Pid.t * ?.ExitStatus.t) Option.t
+      val writeArr: (?.FileDesc.t * Word8.t ?.Sequence.Slice.t) -> Int.t
+      val writeVec: (?.FileDesc.t * Word8.t VectorSlice.t) -> Int.t
       structure AccessMode:
 	 sig
 	    type t = ?.AccessMode.t
@@ -1370,7 +1372,7 @@
 	    val notsup: ?.Error.t
 	    val notty: ?.Error.t
 	    val nxio: ?.Err...
 
[truncated message content]