mlton-commit

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

First cut at my basis library replacement.

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

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

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


Property changes on: mltonlib/trunk/com/sweeks/basic/unstable
___________________________________________________________________
Name: svn:ignore
   + TAGS


Added: mltonlib/trunk/com/sweeks/basic/unstable/EXPORT
===================================================================
--- mltonlib/trunk/com/sweeks/basic/unstable/EXPORT	2006-12-07 04:32:24 UTC (rev 4909)
+++ mltonlib/trunk/com/sweeks/basic/unstable/EXPORT	2006-12-07 23:11:38 UTC (rev 4910)
@@ -0,0 +1,2313 @@
+type 'a array = 'a array
+datatype bool = false | true
+eqtype char = char
+type exn = exn
+type 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
+type 'a vector = 'a vector
+type word = word
+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 abs: 'a -> 'a
+val concat: string seq -> 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 o: (('a -> 'b) * ('c -> 'a)) -> ('c -> 'b)
+val print: string -> unit
+val valOf: 'a option -> 'a
+val ~ : 'a -> 'a
+structure Array: ARRAY
+		 where type 'a elem = 'a Array.elem
+		 where type 'a t = 'a ArraySlice.base
+		 where type 'a unfold = 'a Array.unfold
+		 where type 'a unfoldR = 'a Array.unfoldR
+structure ArraySlice: ARRAY_SLICE
+		      where type 'a base = 'a ArraySlice.base
+		      where type 'a elem = 'a ArraySlice.elem
+		      where type 'a t = 'a ArraySlice.t
+structure Bool: BOOL
+structure Char: CHAR
+		where type t = char
+structure CommandLine: COMMAND_LINE
+structure Date: DATE
+		where type Month.t = Date.Month.t
+		where type WeekDay.t = Date.WeekDay.t
+		where type t = Date.t
+structure Dir: DIR
+	       where type Stream.t = Dir.Stream.t
+structure Endian: ENDIAN
+		  where type t = Endian.t
+structure Exn: EXN
+	       where type t = exn
+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
+structure Int16: INT
+		 where type t = Int16.t
+structure Int32: INT
+		 where type t = Int32.t
+structure Int64: INT
+		 where type t = Int64.t
+structure Int8: INT
+		where type t = Int8.t
+structure IntInf: INT_INF
+		  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
+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 = LargeReal.t
+structure LargeWord: WORD
+		     where type t = LargeWord.t
+structure Lazy: LAZY
+structure List: LIST
+		where type 'a elem = 'a List.elem
+		where type 'a unfold = 'a List.unfold
+		where type 'a unfoldR = 'a List.unfoldR
+structure Net: NET
+	       where type Family.inet = Net.Family.inet
+	       where type 'a Family.t = 'a Net.Family.t
+	       where type Family.unix = Net.Family.unix
+	       where type Family.unknown = Net.Family.unknown
+	       where type Host.Address.t = Net.Host.Address.t
+	       where type Host.t = Net.Host.t
+	       where type Protocol.t = Net.Protocol.t
+	       where type Service.t = Net.Service.t
+	       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 ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i) Socket.Receive.Block.t = ('a,
+											 'b,
+											 'c,
+											 'd,
+											 'e,
+											 'f,
+											 'g,
+											 'h,
+											 'i) Net.Socket.Receive.Block.t
+	       where type Socket.Receive.Flag.t = Net.Socket.Receive.Flag.t
+	       where type ('a, 'b, 'c, 'd) Socket.Receive.From.t = ('a,
+								    'b,
+								    'c,
+								    'd) Net.Socket.Receive.From.t
+	       where type ('a, 'b, 'c, 'd, 'e, 'f, 'g) Socket.Receive.To.t = ('a,
+									      'b,
+									      'c,
+									      'd,
+									      'e,
+									      'f,
+									      'g) Net.Socket.Receive.To.t
+	       where type ('a, 'b, 'c, 'd, 'e, 'f, 'g) Socket.Send.Block.t = ('a,
+									      'b,
+									      'c,
+									      'd,
+									      'e,
+									      'f,
+									      'g) Net.Socket.Send.Block.t
+	       where type Socket.Send.Flag.t = Net.Socket.Send.Flag.t
+	       where type Socket.Send.From.t = Net.Socket.Send.From.t
+	       where type ('a, 'b, 'c, 'd) Socket.Send.To.t = ('a, 'b, 'c, 'd) Net.Socket.Send.To.t
+	       where type Socket.ShutdownMode.t = Net.Socket.ShutdownMode.t
+	       where type Socket.Type.active = Net.Socket.Type.active
+	       where type Socket.Type.dgram = Net.Socket.Type.dgram
+	       where type Socket.Type.passive = Net.Socket.Type.passive
+	       where type 'a Socket.Type.stream = 'a Net.Socket.Type.stream
+	       where type 'a Socket.Type.t = 'a Net.Socket.Type.t
+	       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
+structure Order: ORDER
+		 where type t = Order.t
+structure Out: OUT
+	       where type t = Out.t
+structure Path: PATH
+		where type Pieces.t = Path.Pieces.t
+structure Poll: POLL
+		where type Desc.t = Poll.Desc.t
+		where type Info.t = Poll.Info.t
+structure Posix: POSIX
+		 where type AccessMode.t = Posix.AccessMode.t
+		 where type Dev.t = Posix.Dev.t
+		 where type DirStream.t = Posix.DirStream.t
+		 where type Error.t = Posix.Error.t
+		 where type ExitStatus.t = Posix.ExitStatus.t
+		 where type ('a, 'b) Fcntl.t = ('a, 'b) Posix.Fcntl.t
+		 where type FileDesc.t = Posix.FileDesc.t
+		 where type FileDescFlags.t = Posix.FileDescFlags.t
+		 where type FileStatusFlags.t = Posix.FileStatusFlags.t
+		 where type FlowAction.t = Posix.FlowAction.t
+		 where type Gid.t = Posix.Gid.t
+		 where type Group.t = Posix.Group.t
+		 where type Ino.t = Posix.Ino.t
+		 where type KillArg.t = Posix.KillArg.t
+		 where type Lock.Type.t = Posix.Lock.Type.t
+		 where type Lock.t = Posix.Lock.t
+		 where type Mode.t = Posix.Mode.t
+		 where type OpenFlags.t = Posix.OpenFlags.t
+		 where type OpenMode.t = Posix.OpenMode.t
+		 where type Passwd.t = Posix.Passwd.t
+		 where type Pid.t = Posix.Pid.t
+		 where type QueueSel.t = Posix.QueueSel.t
+		 where type SetAction.t = Posix.SetAction.t
+		 where type Signal.t = Posix.Signal.t
+		 where type Stat.t = Posix.Stat.t
+		 where type Termios.C.t = Posix.Termios.C.t
+		 where type Termios.CC.t = Posix.Termios.CC.t
+		 where type Termios.I.t = Posix.Termios.I.t
+		 where type Termios.L.t = Posix.Termios.L.t
+		 where type Termios.O.t = Posix.Termios.O.t
+		 where type Termios.Speed.t = Posix.Termios.Speed.t
+		 where type Termios.t = Posix.Termios.t
+		 where type Uid.t = Posix.Uid.t
+		 where type WaitPidArg.t = Posix.WaitPidArg.t
+		 where type WaitPidFlags.t = Posix.WaitPidFlags.t
+		 where type Whence.t = Posix.Whence.t
+structure Process: PROCESS
+		   where type Status.t = Process.Status.t
+structure Radix: RADIX
+		 where type t = Radix.t
+structure Real: PACKABLE_REAL
+		where type Class.t = Real.Class.t
+		where type Format.t = Real.Format.t
+		where type RoundingMode.t = Real.RoundingMode.t
+		where type t = Real.t
+structure Real32: PACKABLE_REAL
+		  where type Class.t = Real32.Class.t
+		  where type Format.t = Real32.Format.t
+		  where type RoundingMode.t = Real32.RoundingMode.t
+		  where type t = Real32.t
+structure Real64: PACKABLE_REAL
+		  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
+structure Ref: REF
+structure Scanner: SCANNER
+		   where type 'a t = 'a Scanner.t
+structure Seq: SEQ
+	       where type 'a elem = 'a Seq.elem
+	       where type 'a t = 'a seq
+	       where type 'a unfold = 'a Seq.unfold
+	       where type 'a unfoldR = 'a Seq.unfoldR
+structure String: STRING
+		  where type t = string
+		  where type 'a unfold = 'a String.unfold
+		  where type 'a unfoldR = 'a String.unfoldR
+structure Substring: SUBSTRING
+		     where type 'a base = 'a Substring.base
+		     where type t = Substring.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 Vector: VECTOR
+		  where type 'a elem = 'a Vector.elem
+		  where type 'a t = 'a vector
+		  where type 'a unfold = 'a Vector.unfold
+		  where type 'a unfoldR = 'a Vector.unfoldR
+structure VectorSlice: VECTOR_SLICE
+		       where type 'a base = 'a vector
+		       where type 'a elem = 'a VectorSlice.elem
+		       where type 'a t = 'a VectorSlice.t
+structure Word: WORD
+		where type t = word
+structure Word16: WORD
+		  where type t = Word16.t
+structure Word32: PACKABLE_WORD
+		  where type t = Word32.t
+structure Word64: WORD
+		  where type t = Word64.t
+structure Word8: WORD
+		 where type t = Word8.t
+signature ARRAY = 
+   sig
+      type 'a elem = 'a ?.elem
+      type 'a t = 'a ?.t
+      type 'a t0 = 'a ?.t
+      type 'a unfold = 'a ?.unfold
+      type 'a unfoldR = 'a ?.unfoldR
+      val all: ('a ?.t * ('a ?.elem -> bool)) -> bool
+      val append: ('a ?.t * 'a ?.t) -> 'a ?.t
+      val concat: 'a ?.t seq -> '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 * Int32.t) -> 'a ?.t
+      val dropSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
+      val dropSuffixN: ('a ?.t * Int32.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 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 * Int32.t) -> 'a ?.t
+      val keepSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
+      val keepSuffixN: ('a ?.t * Int32.t) -> 'a ?.t
+      val last: 'a ?.t -> 'a ?.elem
+      val make: (Int32.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 * Int32.t) -> 'a ?.t
+      val recur: ('a ?.t
+		  * 'b
+		  * ('b -> 'c)
+		  * (('a ?.elem * 'b * ('b -> 'c)) -> 'c))
+		 -> 'c
+      val reverse: 'a ?.t -> 'a ?.t
+      val separate: ('a ?.t * 'a ?.elem) -> 'a ?.t
+      val single: 'a ?.elem -> 'a ?.t
+      val size: 'a ?.t -> Int32.t
+      val splitPrefix: ('a ?.t * ('a ?.elem -> bool)) -> ('a ?.t * 'a ?.t)
+      val sub: ('a ?.t * Int32.t) -> 'a ?.elem
+      val tabulate: (Int32.t * (Int32.t -> '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))
+		  -> ('b ?.t * 'a ?.unfold)
+      val unfoldN: (Int32.t * 'a * ((Int32.t * 'a) -> ('b ?.elem * 'a) option))
+		   -> ('b ?.t * 'a ?.unfold)
+      val unfoldNR: (Int32.t * 'a * ((Int32.t * 'a) -> ('b ?.elem * 'a) option))
+		    -> ('b ?.t * 'a ?.unfoldR)
+      val unfoldR: ('a * ('a -> ('b ?.elem * 'a) option))
+		   -> ('b ?.t * 'a ?.unfoldR)
+      val update: ('a ?.t * Int32.t * 'a) -> unit
+      val updates: ('a ?.t * Int32.t * 'a seq) -> unit
+      structure Unsafe:
+	 sig
+	    val make: Int32.t -> 'a ?.t
+	    val sub: ('a ?.t * Int32.t) -> 'a
+	    val update: ('a ?.t * Int32.t * 'a) -> unit
+	 end
+   end
+signature ARRAY_SLICE = 
+   sig
+      type 'a base = 'a ?.base
+      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: Int32.t})
+      val dropPrefix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
+      val dropPrefixN: ('a ?.t * Int32.t) -> 'a ?.t
+      val dropSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
+      val dropSuffixN: ('a ?.t * Int32.t) -> '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 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 * Int32.t) -> 'a ?.t
+      val keepSuffix: ('a ?.t * ('a ?.elem -> bool)) -> 'a ?.t
+      val keepSuffixN: ('a ?.t * Int32.t) -> 'a ?.t
+      val last: 'a ?.t -> 'a ?.elem
+      val map: ('a ?.t * ('a ?.elem -> 'b ?.elem)) -> 'b ?.base
+      val recur: ('a ?.t
+		  * 'b
+		  * ('b -> 'c)
+		  * (('a ?.elem * 'b * ('b -> 'c)) -> 'c))
+		 -> 'c
+      val size: 'a ?.t -> Int32.t
+      val slice: ('a ?.t * {size: Int32.t, start: Int32.t}) -> 'a ?.t
+      val splitPrefix: ('a ?.t * ('a ?.elem -> bool)) -> ('a ?.t * 'a ?.t)
+      val sub: ('a ?.t * Int32.t) -> '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
+   end
+signature BOOL = 
+   sig
+      datatype t = false | true
+      val not: bool -> bool
+   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: Int32.t -> ?.t
+      val toInt: ?.t -> Int32.t
+      val toLower: ?.t -> ?.t
+      val toUpper: ?.t -> ?.t
+   end
+signature COMMAND_LINE = 
+   sig
+      val arguments: unit -> string list
+      val name: unit -> string
+   end
+signature DATE = 
+   sig
+      type t = ?.t
+      val format: (?.t * string) -> string
+      val hour: ?.t -> Int32.t
+      val isDst: ?.t -> bool option
+      val localOffset: unit -> Time.t
+      val make: {hour: Int32.t,
+		 minute: Int32.t,
+		 month: ?.Month.t,
+		 monthDay: Int32.t,
+		 offset: Time.t option,
+		 second: Int32.t,
+		 year: Int32.t}
+		-> ?.t
+      val minute: ?.t -> Int32.t
+      val month: ?.t -> ?.Month.t
+      val monthDay: ?.t -> Int32.t
+      val ofString: string -> ?.t option
+      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 -> Int32.t
+      val toString: ?.t -> string
+      val toTime: ?.t -> Time.t
+      val weekDay: ?.t -> ?.WeekDay.t
+      val year: ?.t -> Int32.t
+      val yearDay: ?.t -> Int32.t
+      structure Month:
+	 sig
+	    type t = ?.Month.t
+	    val april: ?.Month.t
+	    val august: ?.Month.t
+	    val december: ?.Month.t
+	    val february: ?.Month.t
+	    val january: ?.Month.t
+	    val july: ?.Month.t
+	    val june: ?.Month.t
+	    val march: ?.Month.t
+	    val may: ?.Month.t
+	    val november: ?.Month.t
+	    val october: ?.Month.t
+	    val september: ?.Month.t
+	 end
+      structure WeekDay:
+	 sig
+	    type t = ?.WeekDay.t
+	    val friday: ?.WeekDay.t
+	    val monday: ?.WeekDay.t
+	    val saturday: ?.WeekDay.t
+	    val sunday: ?.WeekDay.t
+	    val thursday: ?.WeekDay.t
+	    val tuesday: ?.WeekDay.t
+	    val wednesday: ?.WeekDay.t
+	 end
+   end
+signature DIR = 
+   sig
+      eqtype t = string
+      val changeTo: string -> unit
+      val create: string -> unit
+      val current: unit -> string
+      val openStream: string -> ?.Stream.t
+      val remove: string -> unit
+      structure Stream:
+	 sig
+	    type t = ?.Stream.t
+	    val close: ?.Stream.t -> unit
+	    val read: ?.Stream.t -> string option
+	    val rewind: ?.Stream.t -> unit
+	 end
+   end
+signature ENDIAN = 
+   sig
+      datatype t = Big | Little
+   end
+signature EXN = 
+   sig
+      type t = ?.t
+      val finally: ((unit -> 'a) * (unit -> unit)) -> 'a
+      val try: ((unit -> 'a) * ('a -> 'b) * (?.t -> 'b)) -> 'b
+   end
+signature FILE = 
+   sig
+      eqtype t = string
+      val canAccess: (string * ?.AccessMode.t list) -> bool
+      val id: string -> ?.Id.t
+      val modTime: string -> Time.t
+      val openIn: string -> In.t
+      val openOut: string -> Out.t
+      val remove: string -> unit
+      val rename: {new: string, old: string} -> unit
+      val setTime: (string * Time.t) -> unit
+      val size: string -> Int64.t
+      val temp: {prefix: string, suffix: string} -> (string * Out.t)
+      val withIn: (string * (In.t -> 'a)) -> 'a
+      val withOut: (string * (Out.t -> 'a)) -> 'a
+      structure AccessMode:
+	 sig
+	    type t = ?.AccessMode.t
+	    val exec: ?.AccessMode.t
+	    val read: ?.AccessMode.t
+	    val write: ?.AccessMode.t
+	 end
+      structure Id:
+	 sig
+	    type t = ?.Id.t
+	    val == : (?.Id.t * ?.Id.t) -> bool
+	    val compare: (?.Id.t * ?.Id.t) -> order
+	    val hash: ?.Id.t -> Word32.t
+	 end
+   end
+signature IN = 
+   sig
+      type t = ?.t
+      val close: ?.t -> unit
+      val get1: ?.t -> char option
+      val getAll: ?.t -> string
+      val getLine: ?.t -> string option
+      val lines: ?.t -> string seq
+      val standard: ?.t
+   end
+signature INT = 
+   sig
+      type 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 compare: (?.t * ?.t) -> order
+      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 mod: (?.t * ?.t) -> ?.t
+      val ofString: string -> ?.t option
+      val ofStringRadix: (string * Radix.t) -> ?.t option
+      val quot: (?.t * ?.t) -> ?.t
+      val rem: (?.t * ?.t) -> ?.t
+      val scanner: Radix.t -> (char seq -> (?.t * char seq) option)
+      val toString: ?.t -> string
+      val toStringRadix: (?.t * Radix.t) -> string
+      val toWord: ?.t -> Word32.t
+   end
+signature INT_INF = 
+   sig
+      type 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 compare: (?.t * ?.t) -> order
+      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 mod: (?.t * ?.t) -> ?.t
+      val ofString: string -> ?.t option
+      val ofStringRadix: (string * Radix.t) -> ?.t option
+      val quot: (?.t * ?.t) -> ?.t
+      val rem: (?.t * ?.t) -> ?.t
+      val scanner: Radix.t -> (char seq -> (?.t * char seq) option)
+      val toString: ?.t -> string
+      val toStringRadix: (?.t * Radix.t) -> string
+      val toWord: ?.t -> Word32.t
+   end
+signature IO_DESC = 
+   sig
+      type t = ?.t
+      val compare: (?.t * ?.t) -> order
+      val hash: ?.t -> Word32.t
+      structure Kind:
+	 sig
+	    type t = ?.Kind.t
+	    val == : (?.Kind.t * ?.Kind.t) -> bool
+	    val device: ?.Kind.t
+	    val dir: ?.Kind.t
+	    val file: ?.Kind.t
+	    val pipe: ?.Kind.t
+	    val socket: ?.Kind.t
+	    val symlink: ?.Kind.t
+	    val tty: ?.Kind.t
+	 end
+   end
+signature LAZY = 
+   sig
+      val memo: (unit -> 'a) -> (unit -> 'a)
+   end
+signature LIST = 
+   sig
+      type 'a elem = 'a ?.elem
+      datatype 'a t = nil | :: of 'a * 'a list
+      eqtype 'a t0 = 'a list
+      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 * Int32.t) -> 'a list
+      val dropSuffix: ('a list * ('a ?.elem -> bool)) -> 'a list
+      val dropSuffixN: ('a list * Int32.t) -> '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 * Int32.t) -> 'a list
+      val keepSuffix: ('a...
 
[truncated message content]