path: root/src/mosmllib/test/result.ok

Moscow ML version 2.10
Enter `quit();' to quit.
[opening file "test.sml"]
[opening file "array.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val it = () : unit
> val a = <array> : int array
  val b = <array> : int array
  val c = <array> : int array
  val test1 = "OK" : string
  val test2 = "OK" : string
  val d = <array> : int array
  val test3 = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val e = <array> : int array
  val 'a a2v = fn : 'a array -> 'a vector
  val ev =
    #[1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41,
      51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
      41, 51, 61, 1, 11, 441, 551, 661, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
      41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11,
      21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, ...] : int vector
  val test7 = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val f = #[441, 551, 661] : int vector
  val test9 = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val g = <array> : int array
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val array0 = <array> : int array
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test13a = "OK" : string
  val test13b = "OK" : string
  val test14a = "OK" : string
  val test14b = "OK" : string
  val test14c = "OK" : string
  val test15a = "OK" : string
  val test16a = "OK" : string
  val test17 = "OK" : string
[closing file "array.sml"]
[opening file "array2.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val a0 = <array> : int array
  val fill = fn : int * int -> int
  val a = <array> : int array
  val test0a = "OK" : string
  val test0b = "OK" : string
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test1d = "OK" : string
  val test1e = "OK" : string
  val test1f = "OK" : string
  val test2 = "OK" : string
  val test3a = "OK" : string
  val test3b = "OK" : string
  val test3c = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test5c = "OK" : string
  val test5d = "OK" : string
  val a1 = <array> : int array
  val testcopy = fn :
  {col : int, ncols : int option, nrows : int option, row : int} -> int ->
  int -> (int array -> bool) -> string
  val same = fn : int array -> bool
  val ''a elts = fn : ''a vector list -> ''a array -> bool
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val test6d = "OK" : string
  val test6e = "OK" : string
  val test6f = "OK" : string
  val test6g = "OK" : string
  val 'a ### = fn : 'a list -> 'a vector
  val test6h = "OK" : string
  val test6i = "OK" : string
  val test6j = "OK" : string
  val test6k = "OK" : string
  val test6l = "OK" : string
  val test6m = "OK" : string
  val test6n = "OK" : string
  val test6o = "OK" : string
  val failcopy = fn :
  {col : int, ncols : int option, nrows : int option, row : int} -> int ->
  int -> string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test7c = "OK" : string
  val test7d = "OK" : string
  val test7e = "OK" : string
  val test7f = "OK" : string
  val test7g = "OK" : string
  val test7h = "OK" : string
  val test7i = "OK" : string
  val test7j = "OK" : string
  val test7k = "OK" : string
  val test7l = "OK" : string
  val test7m = "OK" : string
  val test7n = "OK" : string
  val sequence = ref [12, 11, 2, 1] : int list ref
  val collect = fn : int -> unit
  val collecti = fn : int * int * int -> unit
  val a3 = <array> : int array
  val test8aa = "OK" : string
  val test8ab = "OK" : string
  val test8ba = "OK" : string
  val test8bb = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test8g = "OK" : string
  val test8h = "OK" : string
  val test8i = "OK" : string
  val test8j = "OK" : string
  val test8k = "OK" : string
  val test8l = "OK" : string
  val chkmodify = fn : int list -> (int array -> bool) -> string
  val chkmodifyi = fn :
  {col : int, ncols : int option, nrows : int option, row : int} -> int list ->
  (int array -> bool) -> string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val test9d = "OK" : string
  val test9e = "OK" : string
  val test9f = "OK" : string
  val test9g = "OK" : string
  val test9h = "OK" : string
  val test9i = "OK" : string
  val test9j = "OK" : string
  val test9k = "OK" : string
  val test9l = "OK" : string
  val chkfold = fn : traversal -> int list -> string
  val chkfoldi = fn :
  traversal ->
  {col : int, ncols : int option, nrows : int option, row : int} -> int list ->
  string
  val test10a1 = "OK" : string
  val test10a2 = "OK" : string
  val test10b1 = "OK" : string
  val test10b2 = "OK" : string
  val test10c1 = "OK" : string
  val test10c2 = "OK" : string
  val test10d1 = "OK" : string
  val test10d2 = "OK" : string
  val test10e1 = "OK" : string
  val test10e2 = "OK" : string
  val test10f1 = "OK" : string
  val test10f2 = "OK" : string
  val test10g1 = "OK" : string
  val test10g2 = "OK" : string
  val test10h1 = "OK" : string
  val test10h2 = "OK" : string
  val test10i1 = "OK" : string
  val test10i2 = "OK" : string
  val test10j1 = "OK" : string
  val test10j2 = "OK" : string
  val test10k1 = "OK" : string
  val test10k2 = "OK" : string
  val test10l1 = "OK" : string
  val test10l2 = "OK" : string
  val faili = fn :
  {col : int, ncols : int option, nrows : int option, row : int} -> string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test11f = "OK" : string
  val test11g = "OK" : string
  val test11h = "OK" : string
  val ''a chkfromlist = fn : ''a list list -> string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test12j = "OK" : string
  val test12k = "OK" : string
  val test12l = "OK" : string
[closing file "array2.sml"]
[opening file "arrayslice.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val a = <array> : int array
  val b = <array> : int array
  val c = <array> : int array
  val slice00 = <slice> : int slice
  val slice01 = <slice> : int slice
  val slice02 = <slice> : int slice
  val slice03 = <slice> : int slice
  val slice04 = <slice> : int slice
  val slice05 = <slice> : int slice
  val slicea07 = <slice> : int slice
  val slicea02 = <slice> : int slice
  val slicea23 = <slice> : int slice
  val slicea25 = <slice> : int slice
  val slice06 = <slice> : int slice
  val slice07 = <slice> : int slice
  val slice08 = <slice> : int slice
  val slice09 = <slice> : int slice
  val slice0s =
    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
     <slice>, <slice>] : int slice list
  val sliceas = [<slice>, <slice>, <slice>, <slice>] : int slice list
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test2e = "OK" : string
  val test3a = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test4e = "OK" : string
  val test4f = "OK" : string
  val test4g = "OK" : string
  val test5 = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val sliced = <slice> : int slice
  val sliceb = <slice> : int slice
  val e = <array> : int array
  val ev =
    #[1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41,
      51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
      41, 51, 61, 1, 11, 441, 551, 661, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
      41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11,
      21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, ...] : int vector
  val slicee = <slice> : int slice
  val test9a = "OK" : string
  val test9b = "OK" : string
  val g = <array> : int array
  val sliceg = <slice> : int slice
  val test10a = "OK" : string
  val sliceg0 = <slice> : int slice
  val test10b = "OK" : string
  val sliceg1 = <slice> : int slice
  val test10c = "OK" : string
  val sliceg202 = <slice> : int slice
  val test10d = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test13 = "OK" : string
  val test14a = "OK" : string
  val test14b = "OK" : string
  val test15 = "OK" : string
  val test16 = "OK" : string
  val test17a = "OK" : string
  val test17b = "OK" : string
[closing file "arrayslice.sml"]
[opening file "arraysort.sml"]
> val it = () : unit
> val it = () : unit
> val it = () : unit
> val a = <array> : real array
> val test1 = true : bool
> val test2 = true : bool
[closing file "arraysort.sml"]
[opening file "bytechar.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val test7 = "OK" : string
  val test8 = "OK" : string
  val test9 = "OK" : string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test10f = "OK" : string
  val test10g = "OK" : string
  val test10h = "OK" : string
  val test10i = "OK" : string
  val test10j = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test11f = "OK" : string
  val test11g = "OK" : string
  val test11h = "OK" : string
  val test11i = "OK" : string
  val test11j = "OK" : string
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22 = "OK" : string
  val test23 = "OK" : string
  val test24 = "OK" : string
  val test25 = "OK" : string
  val test26 = "OK" : string
  val test27 = "OK" : string
  val test28 = "OK" : string
  val test29 = "OK" : string
  val test30 = "OK" : string
  val test31 = "OK" : string
  val test32 = "OK" : string
  val test33 = "OK" : string
  val test34a = "OK" : string
  val test34b = "OK" : string
  val test35a = "OK" : string
  val test35b = "OK" : string
  val test36 = "OK" : string
  val test37 = "OK" : string
  val test38 = "OK" : string
  val test39 = "OK" : string
  val test40 = "OK" : string
  val test41 = "OK" : string
  val test42 = "OK" : string
  val test43 = "OK" : string
[closing file "bytechar.sml"]
[opening file "callback.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val it = () : unit
> val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test1d = "OK" : string
  val test2a = "OK" : string
  val test3a = "OK" : string
[closing file "callback.sml"]
[opening file "date.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
VARYING: This is (local time) now:        Fri Jul  2 20:31:32 2021
VARYING: This is UTC now:                 Fri Jul  2 18:31:32 2021
VARYING: This is an hour from now:        Fri Jul  2 21:31:32 2021
VARYING: This is a day from now:          Sat Jul  3 20:31:32 2021
VARYING: This is a week from now:         Fri Jul  9 20:31:32 2021
VARYING: This is 120 days from now:       Sat Oct 30 20:31:32 2021
VARYING: This is 160 days from now:       Thu Dec  9 19:31:32 2021
VARYING: This is 200 days from now:       Tue Jan 18 19:31:32 2022
VARYING: This is 240 days from now:       Sun Feb 27 19:31:32 2022
VARYING: This is the epoch (UTC):         Thu Jan  1 00:00:00 1970
The UTC millenium (UTC time):    Sat Jan  1 00:00:00 2000
The UTC millenium (UTC time):    Sat Jan  1 00:00:00 2000
The UTC millenium minus 5 sec:   Fri Dec 31 23:59:55 1999
VARYING: The UTC millenium (local time):  Sat Jan  1 01:00:00 2000
VARYING: The local millenium (UTC time):  Fri Dec 31 23:00:00 1999
The UTC+01 millenium (UTC):      Fri Dec 31 23:00:00 1999
The UTC-01 millenium (UTC):      Sat Jan  1 01:00:00 2000
VARYING: This is today's number:          183 (internally: 182)
VARYING: This is today's weekday:         Friday
VARYING: This is the name of this month:  July
VARYING: Today's ISO date:                2021-07-02
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val addh = fn : int -> month * int * int
  val test7 = "OK" : string
  val test8 = "OK" : string
  val test9 = "OK" : string
[closing file "date.sml"]
[opening file "filesys.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1a = "OK" : string
  val test1b = "OK" : string
  val test2 = "OK" : string
  val test3a = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test5 = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val test6d = "OK" : string
  val test6e = "OK" : string
  val test6f = "OK" : string
  val test6g = "OK" : string
  val test6h = "OK" : string
  val test6i = "OK" : string
  val test6j = "OK" : string
  val test6k = "OK" : string
  val test6l = "OK" : string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test7c = "OK" : string
  val test7d = "OK" : string
  val test7e = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test8g = "OK" : string
  val test8h = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test13a = "OK" : string
  val test13b = "OK" : string
  val test13c = "OK" : string
  val test13d = "OK" : string
  val test13e = "OK" : string
  val test14 = "OK" : string
  val test15a = "OK" : string
  val test15b = "OK" : string
  val test15c = "OK" : string
  val test15d = "OK" : string
  val test15e = "OK" : string
  val test15f = "OK" : string
[closing file "filesys.sml"]
[opening file "general.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> exn NoExceptionRaised = NoExceptionRaised : exn
  val 'a getExn = fn : (unit -> 'a) -> exn
  val prExn = fn : string * exn -> unit
> exn E1 = E1 : exn
> exn E2 = E2 : exn
File "general.sml", line 20, characters 42-46:
!      ("Bind",      getExn(fn _ => let val true = false in () end)),
!                                           ^^^^
! Warning: pattern matching is not exhaustive
 
File "general.sml", line 21, characters 35-48:
!      ("Match",     getExn(fn _ => (fn true => ()) false)),
!                                    ^^^^^^^^^^^^^
! Warning: pattern matching is not exhaustive
Should be `E1 or E2':
  E1
  E1
Should be `Bind':
  Bind
  Bind
Should be `Match':
  Match
  Match
Should be `Subscript':
  Subscript
  Subscript
Should be `Size':
  Size
  Size
Should be `Div':
  Div
  Div
Should be `Chr':
  Chr
  Chr
Should be `Fail':
  Fail
  Fail: demo
Should be `Option':
  Option
  Option
Should be `Empty':
  Empty
  Empty
Should be `SysErr':
  SysErr
  SysErr: modTime failed on `exists.not': No such file or directory
Should be `Io':
  Io
  Io: openOut failed on `.'; SysErr: Is a directory
 
[closing file "general.sml"]
[opening file "int.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test1d = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val test12 = "OK" : string
  val ('a, ''b) chk = fn : ('a -> ''b option) -> 'a * ''b -> string
  val chkScan = fn : radix -> string * int -> string
  val test13a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test13b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test14a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test14b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test15a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test15b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test16a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test16b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK"] : string list
  val test17a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK"] : string list
  val test17b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22 = "OK" : string
[closing file "int.sml"]
[opening file "list.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val v123 = [1, 2, 3] : int list
  val even = fn : int -> bool
  val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val test7 = "OK" : string
  val test8 = "OK" : string
  val test9 = "OK" : string
  val test10 = "OK" : string
  val v16 = [1, 2, 3, 4, 5, 6] : int list
  val test11 = "OK" : string
  val test12 = "OK" : string
  val test13 = "OK" : string
  val reset = fn : unit -> unit
  val incrv = fn : int -> unit
  val checkv = fn : unit -> string
  val test14 = fn : unit -> string
  val test15a = "OK" : string
  val test15b = fn : unit -> string
  val test16 = "OK" : string
  val test17 = "OK" : string
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22 = "OK" : string
  val test23 = "OK" : string
  val test24 = "OK" : string
  val test25 = "OK" : string
  val test26 = "OK" : string
  val test27 = "OK" : string
  val test28 = "OK" : string
  val test29 = "OK" : string
  val test30 = "OK" : string
  val test31 = "OK" : string
  val test32 = "OK" : string
  val test33 = "OK" : string
  val test34 = "OK" : string
  val test35a = "OK" : string
  val test35b = "OK" : string
  val test35c = "OK" : string
  val test36a = "OK" : string
  val test36b = "OK" : string
  val test36c = "OK" : string
  val test37a = "OK" : string
  val test38 = "OK" : string
[closing file "list.sml"]
[opening file "listpair.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val reset = fn : unit -> unit
  val incrv = fn : int -> unit
  val checkv = fn : unit -> string
  val checkv6 = fn : unit -> string
  val checkv0 = fn : unit -> string
  val test3a = "OK" : string
  val test3b = "OK" : string
  val test4 = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test5c = "OK" : string
  val test5d = "OK" : string
  val test5e = "OK" : string
  val test6 = "OK" : string
  val test7 = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val test9d = "OK" : string
  val test9e = "OK" : string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test13a = "OK" : string
  val test13b = "OK" : string
  val test13c = "OK" : string
[closing file "listpair.sml"]
[opening file "listsort.sml"]
> val it = () : unit
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1r = "OK" : string
  val test1i = "OK" : string
  val test2r = "OK" : string
  val test2i = "OK" : string
  val test3r = "OK" : string
  val test3i = "OK" : string
  val 'a double = fn : 'a list -> 'a list
  val test4 = "OK" : string
  val test5 = "OK" : string
  val inteqccheck = fn :
  (int * int -> order) -> int list -> int list list -> bool
  val f = fn : int list * int list list -> bool
  val test6 = "OK" : string
[closing file "listsort.sml"]
[opening file "math.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test0a = "OK" : string
  val test0b = "OK" : string
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test3a = "OK" : string
  val test3b = "OK" : string
  val test3c = "OK" : string
  val test3d = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test4e = "OK" : string
  val test4f = "OK" : string
  val test4g = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test5c = "OK" : string
  val test5d = "OK" : string
  val test5e = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val test6d = "OK" : string
  val test6e = "OK" : string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test7c = "OK" : string
  val test7d = "OK" : string
  val test7e = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test8g = "OK" : string
  val test8h = "OK" : string
  val test8i = "OK" : string
  val test8j = "OK" : string
  val test8k = "OK" : string
  val test8l = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test12j = "OK" : string
  val test12k = "OK" : string
  val test12l = "OK" : string
  val test12m = "OK" : string
  val test13a = "OK" : string
  val test13b = "OK" : string
  val test13c = "OK" : string
  val test13d = "OK" : string
  val test13e = "OK" : string
  val check14a = "OK" : string
  val check14b = "OK" : string
  val check14c = "OK" : string
  val check14d = "OK" : string
  val check14e = "OK" : string
  val check15a = "OK" : string
  val check15b = "OK" : string
  val check15c = "OK" : string
  val check15d = "OK" : string
  val check15e = "OK" : string
  val check15f = "OK" : string
  val check15g = "OK" : string
[closing file "math.sml"]
[opening file "mosml.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
[closing file "mosml.sml"]
[opening file "polyhash.sml"]
> val it = () : unit
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> New type names: =reflist
  val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val mkstr = fn : int -> string -> string
  val equal = fn : string -> int -> bool
  val unequal = fn : string -> int -> bool
  val blank128 =
    "                                                                                                                                "
     : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val test7 = "OK" : string
  val t = <hash_table> : (int, string) hash_table
  val test8 = "OK" : string
  val test9 = "OK" : string
  val test10 = "OK" : string
[closing file "polyhash.sml"]
[opening file "process.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
sh: nonsuchprogramexists: command not found
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3a = "OK" : string
  val test3b = "OK" : string
  val test3c = "OK" : string
  val test4 = "OK" : string
[closing file "process.sml"]
[opening file "random.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val it = () : unit
> val r42 = fn : generator -> int
  val rmax = fn : generator -> int
  val rlo = fn : generator -> int
  val rhi = fn : generator -> int
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test1d = "OK" : string
  val test1e = "TODO" : string
  val rl42 = fn : int * generator -> int list
  val rlmax = fn : int * generator -> int list
  val rllo = fn : int * generator -> int list
  val rlhi = fn : int * generator -> int list
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test2e = "TODO" : string
  val rl8 = fn : int * generator -> int list
  val test3a = "OK" : string
[closing file "random.sml"]
[opening file "real.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = ["TODO"] : string list
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test5c = ["TODO"] : string list
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = ["TODO"] : string list
  val test7a = "OK" : string
  val test7b = fn : real list -> string
  val test7c = ["TODO"] : string list
  val test8 = "OK" : string
  val chk = fn : string * real -> string
  val test9a = ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK"] : string list
  val test9c =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9d =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9e =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9f =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9g =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9h =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9i =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test9j =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test10 = ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
  val test11a = "OK" : string
  val test11b = "OK" : string
  val chkFIX = fn : real * string * string * string * string -> bool
  val chkFIX' = fn : real * string * string * string * string -> bool
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val chkSCI = fn : real * string * string * string * string -> bool
  val chkSCI' = fn : real * string * string * string * string -> bool
  val test12c = "OK" : string
  val test13a = "OK" : string
  val test13b = "OK" : string
  val chkGEN = fn : real * string * string * string * string -> bool
  val chkGEN' = fn : real * string * string * string * string -> bool
  val test13c = "OK" : string
[closing file "real.sml"]
[opening file "string.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test7 = "OK" : string
  val test8 = "OK" : string
  val test9 = "OK" : string
  val test10 = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test11f = "OK" : string
  val test11g = "OK" : string
  val test11h = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12'a = "OK" : string
  val test12'b = "OK" : string
  val test13a = "OK" : string
  val test13b = "OK" : string
  val test14 = "OK" : string
  val test15 = "OK" : string
  val test16a = "OK" : string
  val test16b = "OK" : string
  val test17 = "OK" : string
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22 = "OK" : string
  val test23 = "OK" : string
  val test24 = "OK" : string
  val test25 = "OK" : string
  val test26 = "OK" : string
  val test27 = "OK" : string
  val test28 = "OK" : string
  val test29 = "OK" : string
[closing file "string.sml"]
[opening file "stringcvt.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> New type names: =result
  val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val test7 = "OK" : string
  val test8 = "OK" : string
  val test9 = "OK" : string
  val test10 = "OK" : string
[closing file "stringcvt.sml"]
[opening file "substring.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test1d = "OK" : string
  val test1e = "OK" : string
  val test1f = "OK" : string
  val test1g = "OK" : string
  val test1h = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test3a = "OK" : string
  val test3b = "OK" : string
  val test3c = "OK" : string
  val test4 = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test6 = "OK" : string
  val test7 = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val test9d = "OK" : string
  val test9e = "OK" : string
  val test9f = "OK" : string
  val test9g = "OK" : string
  val test9h = "OK" : string
  val test12 = "OK" : string
  val test13 = "OK" : string
  val test14 = "OK" : string
  val finda = fn : char -> bool
  val findb = fn : char -> bool
  val test15 = "OK" : string
  val test16 = "OK" : string
  val test17 = "OK" : string
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22a = "OK" : string
  val test22b = "OK" : string
  val test23 = "OK" : string
  val test24 = "OK" : string
  val test25 = "OK" : string
  val test26a = "OK" : string
  val test26b = "OK" : string
  val test27a = "OK" : string
  val test27b = "OK" : string
  val test28 = "OK" : string
  val test29a = "OK" : string
  val test29b = "OK" : string
  val test29c = "OK" : string
  val test30a = "OK" : string
  val test30b = "OK" : string
  val test30c = "OK" : string
  val test30d = "OK" : string
  val test30e = "OK" : string
  val test30f = "OK" : string
  val test31a = "OK" : string
  val test31b = "OK" : string
  val test31c = "OK" : string
  val eqspan = fn : substring * substring * substring -> bool
  val test32a = "OK" : string
  val test32c = "OK" : string
  val test32d = "OK" : string
  val test32b = "OK" : string
  val test33a = "OK" : string
  val test33b = "OK" : string
  val test34 = "OK" : string
[closing file "substring.sml"]
[opening file "textio.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
Two lines of output follow:
1234  <--- this should read 1234
12345 <--- this should read 12345
Two lines of output follow:
abcde <--- this should read abcde
abcde <--- this should read abcde
> val empty = <outstream> : outstream
  val small = <outstream> : outstream
  val medium = <outstream> : outstream
  val text = <outstream> : outstream
  val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5 = "OK" : string
  val test6 = "OK" : string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test7c = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val test9d = "OK" : string
  val test9e = "OK" : string
  val test9na = "OK" : string
  val test9nb = "OK" : string
  val test9nc = "OK" : string
  val test9nd = "OK" : string
  val test9ne = "OK" : string
  val test9nf = "OK" : string
  val test10 = "OK" : string
  val test11 = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
[closing file "textio.sml"]
[opening file "time.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test3a = "OK" : string
  val test4a = "OK" : string
  val test6a = "OK" : string
  val test7a = "OK" : string
  val test8a = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val chk = fn : string * int -> string
  val test10a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK"] : string list
  val test10b = ["OK", "OK", "OK", "OK", "OK", "OK"] : string list
[closing file "time.sml"]
[opening file "timer.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
 
Each line below should show roughly the same User, System, and Gc times:
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
User: 0.009  System: 0.000  Gc: 0.000  Real: 0.009
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val ctmr = <cpu_timer> : cpu_timer
  val test4 = "OK" : string
[closing file "timer.sml"]
[opening file "unixpath.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1a = "OK" : string
  val test1b = "OK" : string
  val test1c = "OK" : string
  val test1d = "OK" : string
  val test1e = "OK" : string
  val test1f = "OK" : string
  val test1g = "OK" : string
  val test1h = "OK" : string
  val test1i = "OK" : string
  val test1j = "OK" : string
  val test1k = "OK" : string
  val test1l = "OK" : string
  val test1m = "OK" : string
  val test1n = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test2e = "OK" : string
  val test2f = "OK" : string
  val test2g = "OK" : string
  val test2h = "OK" : string
  val test2i = "OK" : string
  val test2j = "OK" : string
  val test2k = "OK" : string
  val test2l = "OK" : string
  val test2m = "OK" : string
  val test2n = "OK" : string
  val test2o = "OK" : string
  val test2p = "OK" : string
  val test3b = "OK" : string
  val test3c = "OK" : string
  val test3d = "OK" : string
  val test3e = "OK" : string
  val test3f = "OK" : string
  val test3g = "OK" : string
  val test3h = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test5a = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val mka = fn : string * string -> string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test7c = "OK" : string
  val mkr = fn : string * string -> string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test9a = "OK" : string
  val test10a = "OK" : string
  val test11a = "OK" : string
  val test12 = "OK" : string
  val test13 = "OK" : string
  val test14 = "OK" : string
  val test15 = "OK" : string
  val test16 = "OK" : string
  val test17 = "OK" : string
  val test18 = "OK" : string
  val test19 = "OK" : string
[closing file "unixpath.sml"]
[opening file "vector.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('a, 'b) seq = fn : 'a * 'b -> 'b
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
! Warning: Value polymorphism:
! Free type variable(s) at top level in value identifier vec0
> val a = #[0, 1, 2, 3, 4, 5, 6] : int vector
  val b = #[44, 55, 66] : int vector
  val c = #[0, 1, 2, 3, 4, 5, 6] : int vector
  val vec0 = #[] : 'a vector
  val test1 = "OK" : string
  val test2 = "OK" : string
  val d =
    #[0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2,
      3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5,
      6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1,
      2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4,
      5, 6, 0, 1] : int vector
  val test3 = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test5 = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val e =
    #[0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2,
      3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5,
      6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1,
      2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4,
      5, 6, 0, 1, 44, 55, 66, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1,
      2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4,
      5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0,
      1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3,
      4, 5, 6, 0, 1, 2, 3, 4, 5, ...] : int vector
  val test7 = "OK" : string
  val test8 = "OK" : string
  val f = #[44, 55, 66] : int vector
  val test9 = "OK" : string
  val ('b, 'c, ''d) chkiter = fn :
  ((int -> 'b) -> 'c -> ''d) -> (int -> 'b) -> 'c -> ''d * int -> string
  val ('b, 'c, 'd, ''e) chkiteri = fn :
  ((int * 'b -> 'c) -> 'd -> ''e) -> ('b -> 'c) -> 'd -> ''e * int -> string
  val ('b, 'c, 'd, 'e, ''f) chkfold = fn :
  ((int * 'b -> 'c) -> 'd -> 'e -> ''f) -> (int * 'b -> 'c) -> 'd -> 'e ->
  ''f * int -> string
  val ('b, 'c, 'd, 'e, 'f, ''g) chkfoldi = fn :
  ((int * 'b * 'c -> 'd) -> 'e -> 'f -> ''g) -> ('b * 'c -> 'd) -> 'e -> 'f ->
  ''g * int -> string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test10f = "OK" : string
  val test10g = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test13 = "OK" : string
  val test14 = "OK" : string
  val test15 = "OK" : string
  val test16 = "OK" : string
[closing file "vector.sml"]
[opening file "vectorslice.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val a = #[1, 11, 21, 31, 41, 51, 61] : int vector
  val b = #[441, 551, 661] : int vector
  val c = #[1, 11, 21, 31, 41, 51, 61] : int vector
  val slice00 = <slice> : int slice
  val slice01 = <slice> : int slice
  val slice02 = <slice> : int slice
  val slice03 = <slice> : int slice
  val slice04 = <slice> : int slice
  val slice05 = <slice> : int slice
  val slicea07 = <slice> : int slice
  val slicea02 = <slice> : int slice
  val slicea23 = <slice> : int slice
  val slicea25 = <slice> : int slice
  val slice06 = <slice> : int slice
  val slice07 = <slice> : int slice
  val slice08 = <slice> : int slice
  val slice09 = <slice> : int slice
  val slice0s =
    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
     <slice>, <slice>] : int slice list
  val sliceas = [<slice>, <slice>, <slice>, <slice>] : int slice list
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test2e = "OK" : string
  val test3a = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test4e = "OK" : string
  val test4f = "OK" : string
  val test4g = "OK" : string
  val test5 = "OK" : string
  val sliced = <slice> : int slice
  val sliceb = <slice> : int slice
  val e = <array> : int array
  val ev =
    #[1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41,
      51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
      41, 51, 61, 1, 11, 441, 551, 661, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
      41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11,
      21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, ...] : int vector
  val slicee = <slice> : int slice
  val test9a = "OK" : string
  val test9b = "OK" : string
  val g = <array> : int array
  val sliceg = <slice> : int slice
  val test10a = "OK" : string
  val sliceg0 = <slice> : int slice
  val test10b = "OK" : string
  val sliceg1 = <slice> : int slice
  val test10c = "OK" : string
  val sliceg202 = <slice> : int slice
  val test10d = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test13 = "OK" : string
  val test14a = "OK" : string
  val test14b = "OK" : string
  val test15 = "OK" : string
  val test17a = "OK" : string
  val test17b = "OK" : string
[closing file "vectorslice.sml"]
[opening file "weak.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
test1:
test2:
test3:
test4:
test5:
test6:
test7:
test8:
VARYING: /////////////////////////////////////
> val a = <array> : int list array
  val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val b = <array> : int array
  val test5 = "OK" : string
  val c = <array> : string array
  val test6 = "OK" : string
  val test7 = "OK" : string
  val test8 = "OK" : string
[closing file "weak.sml"]
[opening file "word.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test3 = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test8g = "OK" : string
  val test8h = "OK" : string
  val pwr2 = fn : int -> int
  val rwp = fn : int -> int -> int
  val test9a = "OK" : string
  val test9b = "TODO" : string
  val test9c = "TODO" : string
  val test9d = "OK" : string
  val test9e = "OK" : string
  val test9f = "OK" : string
  val test9g = "TODO" : string
  val test9h = "OK" : string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test11f = "OK" : string
  val test11g = "OK" : string
  val test11h = "OK" : string
  val test11i = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test12j = "OK" : string
  val test12k = "OK" : string
  val test12l = "OK" : string
  val test12m = "OK" : string
  val test12n = "OK" : string
  val test12o = "OK" : string
  val test12p = "OK" : string
  val test12q = "OK" : string
  val test12r = "OK" : string
  val test12s = "OK" : string
  val 'b chk = fn : ('b -> word option) -> 'b * int -> string
  val chkScan = fn : radix -> string * int -> string
  val test13a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test13b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test14a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test14b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test15a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test15b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test16a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test16b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK"] : string list
  val test17a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
  val test17b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22 = "OK" : string
[closing file "word.sml"]
[opening file "word8.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val test1 = "OK" : string
  val test2 = "OK" : string
  val test3 = "OK" : string
  val test4 = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test5c = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val test7a = "OK" : string
  val test7b = "OK" : string
  val test7c = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val test8c = "OK" : string
  val test8d = "OK" : string
  val test8e = "OK" : string
  val test8f = "OK" : string
  val test8g = "OK" : string
  val test8h = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val test9c = "OK" : string
  val test9d = "OK" : string
  val test9e = "OK" : string
  val test9f = "OK" : string
  val test9g = "OK" : string
  val test9h = "OK" : string
  val test9i = "OK" : string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test11f = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test12j = "OK" : string
  val test12k = "OK" : string
  val test12l = "OK" : string
  val test12m = "OK" : string
  val test12n = "OK" : string
  val test12o = "OK" : string
  val test12p = "OK" : string
  val test12q = "OK" : string
  val 'b chk = fn : ('b -> word8 option) -> 'b * int -> string
  val chkScan = fn : radix -> string * int -> string
  val test13a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
  val test13b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test13c = "OK" : string
  val test13d = "OK" : string
  val test14a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
  val test14b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test14c = "OK" : string
  val test14d = "OK" : string
  val test15a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK"] : string list
  val test15b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK"] : string list
  val test15c = "OK" : string
  val test15d = "OK" : string
  val test16a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
  val test16b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK"] : string list
  val test16c = "OK" : string
  val test16d = "OK" : string
  val test17a =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
  val test17b =
    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
  string list
  val test17c = "OK" : string
  val test17d = "OK" : string
  val test18 = "OK" : string
  val test19 = "OK" : string
  val test20 = "OK" : string
  val test21 = "OK" : string
  val test22 = "OK" : string
[closing file "word8.sml"]
[opening file "word8array.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val i2w = fn : int -> word8
  val w127 = 0wx7F : word8
  val a = <array> : array
  val b = <array> : array
  val c = <array> : array
  val test1 = "OK" : string
  val test2 = "OK" : string
  val d = <array> : array
  val test3 = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test5a = "OK" : string
  val test5b = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val e = <array> : array
  val a2v = fn : array -> vector/1
  val ev = <vector> : vector/1
  val test7 = "OK" : string
  val test8a = "OK" : string
  val test8b = "OK" : string
  val f = <vector> : vector/1
  val test9 = "OK" : string
  val test9a = "OK" : string
  val test9b = "OK" : string
  val g = <array> : array
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test12 = "OK" : string
  val test13 = "OK" : string
  val test14 = "OK" : string
  val test15 = "OK" : string
[closing file "word8array.sml"]
[opening file "word8arrayslice.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val a = <array> : array
  val b = <array> : array
  val c = <array> : array
  val slice00 = <slice> : slice
  val slice01 = <slice> : slice
  val slice02 = <slice> : slice
  val slice03 = <slice> : slice
  val slice04 = <slice> : slice
  val slice05 = <slice> : slice
  val slicea07 = <slice> : slice
  val slicea02 = <slice> : slice
  val slicea23 = <slice> : slice
  val slicea25 = <slice> : slice
  val slice06 = <slice> : slice
  val slice07 = <slice> : slice
  val slice08 = <slice> : slice
  val slice09 = <slice> : slice
  val slice0s =
    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
     <slice>, <slice>] : slice list
  val sliceas = [<slice>, <slice>, <slice>, <slice>] : slice list
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test2e = "OK" : string
  val test3a = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test4e = "OK" : string
  val test4f = "OK" : string
  val test4g = "OK" : string
  val test5 = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val sliced = <slice> : slice
  val sliceb = <slice> : slice
  val e = <array> : array
  val ev = <vector> : vector/1
  val slicee = <slice> : slice
  val test9a = "OK" : string
  val test9b = "OK" : string
  val g = <array> : array
  val sliceg = <slice> : slice
  val test10a = "OK" : string
  val sliceg0 = <slice> : slice
  val test10b = "OK" : string
  val sliceg1 = <slice> : slice
  val test10c = "OK" : string
  val sliceg202 = <slice> : slice
  val test10d = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12e = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test13 = "OK" : string
  val test14a = "OK" : string
  val test14b = "OK" : string
  val test15 = "OK" : string
  val test16 = "OK" : string
  val test17a = "OK" : string
  val test17b = "OK" : string
[closing file "word8arrayslice.sml"]
[opening file "word8vector.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val a = <vector> : vector/1
  val b = <vector> : vector/1
  val c = <vector> : vector/1
  val test1 = "OK" : string
  val test2 = "OK" : string
  val d = <vector> : vector/1
  val test3 = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test5 = "OK" : string
  val test6a = "OK" : string
  val test6b = "OK" : string
  val test6c = "OK" : string
  val e = <vector> : vector/1
  val test7 = "OK" : string
  val test8 = "OK" : string
  val f = <vector> : vector/1
  val test9 = "OK" : string
  val ('b, 'c, ''d) chkiter = fn :
  ((word8 -> 'b) -> 'c -> ''d) -> (word8 -> 'b) -> 'c -> ''d * word8 -> string
  val ('b, 'c, 'd, ''e) chkiteri = fn :
  ((int * 'b -> 'c) -> 'd -> ''e) -> ('b -> 'c) -> 'd -> ''e * int -> string
  val ('b, 'c, 'd, 'e, ''f) chkfold = fn :
  ((word8 * 'b -> 'c) -> 'd -> 'e -> ''f) -> (word8 * 'b -> 'c) -> 'd -> 'e ->
  ''f * word8 -> string
  val ('b, 'c, 'd, 'e, 'f, ''g) chkfoldi = fn :
  ((int * 'b * 'c -> 'd) -> 'e -> 'f -> ''g) -> ('b * 'c -> 'd) -> 'e -> 'f ->
  ''g * int -> string
  val test10a = "OK" : string
  val test10b = "OK" : string
  val test10c = "OK" : string
  val test10d = "OK" : string
  val test10e = "OK" : string
  val test10f = "OK" : string
  val test10g = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test11d = "OK" : string
  val test11e = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test13 = "OK" : string
  val test14 = "OK" : string
  val test15 = "OK" : string
  val test16 = "OK" : string
[closing file "word8vector.sml"]
[opening file "word8vectorslice.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val a = <vector> : vector/1
  val b = <vector> : vector/1
  val c = <vector> : vector/1
  val slice00 = <slice> : slice
  val slice01 = <slice> : slice
  val slice02 = <slice> : slice
  val slice03 = <slice> : slice
  val slice04 = <slice> : slice
  val slice05 = <slice> : slice
  val slicea07 = <slice> : slice
  val slicea02 = <slice> : slice
  val slicea23 = <slice> : slice
  val slicea25 = <slice> : slice
  val slice06 = <slice> : slice
  val slice07 = <slice> : slice
  val slice08 = <slice> : slice
  val slice09 = <slice> : slice
  val slice0s =
    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
     <slice>, <slice>] : slice list
  val sliceas = [<slice>, <slice>, <slice>, <slice>] : slice list
  val test1a = "OK" : string
  val test1b = "OK" : string
  val test2a = "OK" : string
  val test2b = "OK" : string
  val test2c = "OK" : string
  val test2d = "OK" : string
  val test2e = "OK" : string
  val test3a = "OK" : string
  val test4a = "OK" : string
  val test4b = "OK" : string
  val test4c = "OK" : string
  val test4d = "OK" : string
  val test4e = "OK" : string
  val test4f = "OK" : string
  val test4g = "OK" : string
  val test5 = "OK" : string
  val sliced = <slice> : slice
  val sliceb = <slice> : slice
  val e = <array> : array
  val ev = <vector> : vector/1
  val slicee = <slice> : slice
  val test9a = "OK" : string
  val test9b = "OK" : string
  val g = <array> : array
  val sliceg = <slice> : slice
  val test10a = "OK" : string
  val sliceg0 = <slice> : slice
  val test10b = "OK" : string
  val sliceg1 = <slice> : slice
  val test10c = "OK" : string
  val sliceg202 = <slice> : slice
  val test10d = "OK" : string
  val test11a = "OK" : string
  val test11b = "OK" : string
  val test11c = "OK" : string
  val test12a = "OK" : string
  val test12b = "OK" : string
  val test12c = "OK" : string
  val test12d = "OK" : string
  val test12f = "OK" : string
  val test12g = "OK" : string
  val test12h = "OK" : string
  val test12i = "OK" : string
  val test13 = "OK" : string
  val test14a = "OK" : string
  val test14b = "OK" : string
  val test15 = "OK" : string
  val test17a = "OK" : string
  val test17b = "OK" : string
[closing file "word8vectorslice.sml"]
[opening file "packrealbig.sml"]
[opening file "auxil.sml"]
> infix 1 seq
  val ('b, 'c) seq = fn : 'b * 'c -> 'c
> val check = fn : bool -> string
> val check' = fn : (unit -> bool) -> string
> val range = fn : int * int -> (int -> bool) -> bool
> val checkrange = fn : int * int -> (int -> bool) -> string
[closing file "auxil.sml"]
> val it = () : unit
> val it = () : unit
  ~420.000000 is enconded as C0 7A 40 00 00 00 00 00 (big endian)
  ~1.100000 is enconded as BF F1 99 99 99 99 99 9A (big endian)
  ~0.123457 is enconded as BF BF 9A DD 37 39 63 5F (big endian)
  0.000000 is enconded as 00 00 00 00 00 00 00 00 (big endian)
  0.000000 is enconded as 00 00 00 00 00 00 00 00 (big endian)
  1.000000 is enconded as 3F F0 00 00 00 00 00 00 (big endian)
  1.100000 is enconded as 3F F1 99 99 99 99 99 9A (big endian)
  2.000000 is enconded as 40 00 00 00 00 00 00 00 (big endian)
  420000000.000000 is enconded as 41 B9 08 B1 00 00 00 00 (big endian)
  4611686018427387904.000000 is enconded as 43 D0 00 00 00 00 00 00 (big endian)
  9007199254740991.000000 is enconded as 43 3F FF FF FF FF FF FF (big endian)
  9007199254740992.000000 is enconded as 43 40 00 00 00 00 00 00 (big endian)
  9007199254740992.000000 is enconded as 43 40 00 00 00 00 00 00 (big endian)
  3.141593 is enconded as 40 09 21 FB 54 44 2D 18 (big endian)
  2.718282 is enconded as 40 05 BF 0A 8B 14 57 69 (big endian)
> val roundtrip = fn : real -> bool
  val test_roundtrip = "OK" : string
  val encoded =
    [0wx40, 0wx9, 0wx21, 0wxFB, 0wx54, 0wx44, 0wx2D, 0wx18, 0wx40, 0wx9, 0wx21,
     0wxFB, 0wx54, 0wx44, 0wx2D, 0wx18] : word8 list
  val test_subvec = "OK" : string
  val test_subarr = "OK" : string
  val test_update0 = "OK" : string
  val test_update1 = "OK" : string
[closing file "packrealbig.sml"]
> val it = () : unit