1Moscow ML version 2.01b (June 2005)
2Enter `quit();' to quit.
3[opening file "test.sml"]
4[opening file "array.sml"]
5[opening file "auxil.sml"]
6> infix 1 seq
7  val ('a, 'b) seq = fn : 'a * 'b -> 'b
8> val check = fn : bool -> string
9> val check' = fn : (unit -> bool) -> string
10> val range = fn : int * int -> (int -> bool) -> bool
11> val checkrange = fn : int * int -> (int -> bool) -> string
12[closing file "auxil.sml"]
13> val it = () : unit
14> val it = () : unit
15> val a = <array> : int array
16  val b = <array> : int array
17  val c = <array> : int array
18  val test1 = "OK" : string
19  val test2 = "OK" : string
20  val d = <array> : int array
21  val test3 = "OK" : string
22  val test4a = "OK" : string
23  val test4b = "OK" : string
24  val test4c = "OK" : string
25  val test5a = "OK" : string
26  val test5b = "OK" : string
27  val test6a = "OK" : string
28  val test6b = "OK" : string
29  val test6c = "OK" : string
30  val e = <array> : int array
31  val 'a a2v = fn : 'a array -> 'a vector
32  val ev =
33    #[1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41,
34      51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
35      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
36      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
37      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
38      41, 51, 61, 1, 11, 441, 551, 661, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
39      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
40      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
41      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
42      41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11,
43      21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, ...] : int vector
44  val test7 = "OK" : string
45  val test8a = "OK" : string
46  val test8b = "OK" : string
47  val f = #[441, 551, 661] : int vector
48  val test9 = "OK" : string
49  val test9a = "OK" : string
50  val test9b = "OK" : string
51  val g = <array> : int array
52  val test10a = "OK" : string
53  val test10b = "OK" : string
54  val test10c = "OK" : string
55  val test10d = "OK" : string
56  val test10e = "OK" : string
57  val test11a = "OK" : string
58  val test11b = "OK" : string
59  val test11c = "OK" : string
60  val test11d = "OK" : string
61  val test11e = "OK" : string
62  val array0 = <array> : int array
63  val test12a = "OK" : string
64  val test12b = "OK" : string
65  val test12c = "OK" : string
66  val test12d = "OK" : string
67  val test12e = "OK" : string
68  val test12f = "OK" : string
69  val test12g = "OK" : string
70  val test12h = "OK" : string
71  val test12i = "OK" : string
72  val test13a = "OK" : string
73  val test13b = "OK" : string
74  val test14a = "OK" : string
75  val test14b = "OK" : string
76  val test14c = "OK" : string
77  val test15a = "OK" : string
78  val test16a = "OK" : string
79  val test17 = "OK" : string
80[closing file "array.sml"]
81[opening file "array2.sml"]
82[opening file "auxil.sml"]
83> infix 1 seq
84  val ('a, 'b) seq = fn : 'a * 'b -> 'b
85> val check = fn : bool -> string
86> val check' = fn : (unit -> bool) -> string
87> val range = fn : int * int -> (int -> bool) -> bool
88> val checkrange = fn : int * int -> (int -> bool) -> string
89[closing file "auxil.sml"]
90> val it = () : unit
91> val a0 = <array> : int array
92  val fill = fn : int * int -> int
93  val a = <array> : int array
94  val test0a = "OK" : string
95  val test0b = "OK" : string
96  val test1a = "OK" : string
97  val test1b = "OK" : string
98  val test1c = "OK" : string
99  val test1d = "OK" : string
100  val test1e = "OK" : string
101  val test1f = "OK" : string
102  val test2 = "OK" : string
103  val test3a = "OK" : string
104  val test3b = "OK" : string
105  val test3c = "OK" : string
106  val test4a = "OK" : string
107  val test4b = "OK" : string
108  val test4c = "OK" : string
109  val test4d = "OK" : string
110  val test5a = "OK" : string
111  val test5b = "OK" : string
112  val test5c = "OK" : string
113  val test5d = "OK" : string
114  val a1 = <array> : int array
115  val testcopy = fn :
116  {col : int, ncols : int option, nrows : int option, row : int} -> int ->
117  int -> (int array -> bool) -> string
118  val same = fn : int array -> bool
119  val ''a elts = fn : ''a vector list -> ''a array -> bool
120  val test6a = "OK" : string
121  val test6b = "OK" : string
122  val test6c = "OK" : string
123  val test6d = "OK" : string
124  val test6e = "OK" : string
125  val test6f = "OK" : string
126  val test6g = "OK" : string
127  val 'a ### = fn : 'a list -> 'a vector
128  val test6h = "OK" : string
129  val test6i = "OK" : string
130  val test6j = "OK" : string
131  val test6k = "OK" : string
132  val test6l = "OK" : string
133  val test6m = "OK" : string
134  val test6n = "OK" : string
135  val test6o = "OK" : string
136  val failcopy = fn :
137  {col : int, ncols : int option, nrows : int option, row : int} -> int ->
138  int -> string
139  val test7a = "OK" : string
140  val test7b = "OK" : string
141  val test7c = "OK" : string
142  val test7d = "OK" : string
143  val test7e = "OK" : string
144  val test7f = "OK" : string
145  val test7g = "OK" : string
146  val test7h = "OK" : string
147  val test7i = "OK" : string
148  val test7j = "OK" : string
149  val test7k = "OK" : string
150  val test7l = "OK" : string
151  val test7m = "OK" : string
152  val test7n = "OK" : string
153  val sequence = ref [12, 11, 2, 1] : int list ref
154  val collect = fn : int -> unit
155  val collecti = fn : int * int * int -> unit
156  val a3 = <array> : int array
157  val test8aa = "OK" : string
158  val test8ab = "OK" : string
159  val test8ba = "OK" : string
160  val test8bb = "OK" : string
161  val test8c = "OK" : string
162  val test8d = "OK" : string
163  val test8e = "OK" : string
164  val test8f = "OK" : string
165  val test8g = "OK" : string
166  val test8h = "OK" : string
167  val test8i = "OK" : string
168  val test8j = "OK" : string
169  val test8k = "OK" : string
170  val test8l = "OK" : string
171  val chkmodify = fn : int list -> (int array -> bool) -> string
172  val chkmodifyi = fn :
173  {col : int, ncols : int option, nrows : int option, row : int} -> int list ->
174  (int array -> bool) -> string
175  val test9a = "OK" : string
176  val test9b = "OK" : string
177  val test9c = "OK" : string
178  val test9d = "OK" : string
179  val test9e = "OK" : string
180  val test9f = "OK" : string
181  val test9g = "OK" : string
182  val test9h = "OK" : string
183  val test9i = "OK" : string
184  val test9j = "OK" : string
185  val test9k = "OK" : string
186  val test9l = "OK" : string
187  val chkfold = fn : traversal -> int list -> string
188  val chkfoldi = fn :
189  traversal ->
190  {col : int, ncols : int option, nrows : int option, row : int} -> int list ->
191  string
192  val test10a1 = "OK" : string
193  val test10a2 = "OK" : string
194  val test10b1 = "OK" : string
195  val test10b2 = "OK" : string
196  val test10c1 = "OK" : string
197  val test10c2 = "OK" : string
198  val test10d1 = "OK" : string
199  val test10d2 = "OK" : string
200  val test10e1 = "OK" : string
201  val test10e2 = "OK" : string
202  val test10f1 = "OK" : string
203  val test10f2 = "OK" : string
204  val test10g1 = "OK" : string
205  val test10g2 = "OK" : string
206  val test10h1 = "OK" : string
207  val test10h2 = "OK" : string
208  val test10i1 = "OK" : string
209  val test10i2 = "OK" : string
210  val test10j1 = "OK" : string
211  val test10j2 = "OK" : string
212  val test10k1 = "OK" : string
213  val test10k2 = "OK" : string
214  val test10l1 = "OK" : string
215  val test10l2 = "OK" : string
216  val faili = fn :
217  {col : int, ncols : int option, nrows : int option, row : int} -> string
218  val test11a = "OK" : string
219  val test11b = "OK" : string
220  val test11c = "OK" : string
221  val test11d = "OK" : string
222  val test11e = "OK" : string
223  val test11f = "OK" : string
224  val test11g = "OK" : string
225  val test11h = "OK" : string
226  val ''a chkfromlist = fn : ''a list list -> string
227  val test12a = "OK" : string
228  val test12b = "OK" : string
229  val test12c = "OK" : string
230  val test12d = "OK" : string
231  val test12e = "OK" : string
232  val test12f = "OK" : string
233  val test12g = "OK" : string
234  val test12h = "OK" : string
235  val test12i = "OK" : string
236  val test12j = "OK" : string
237  val test12k = "OK" : string
238  val test12l = "OK" : string
239[closing file "array2.sml"]
240[opening file "arrayslice.sml"]
241[opening file "auxil.sml"]
242> infix 1 seq
243  val ('a, 'b) seq = fn : 'a * 'b -> 'b
244> val check = fn : bool -> string
245> val check' = fn : (unit -> bool) -> string
246> val range = fn : int * int -> (int -> bool) -> bool
247> val checkrange = fn : int * int -> (int -> bool) -> string
248[closing file "auxil.sml"]
249> val it = () : unit
250> val a = <array> : int array
251  val b = <array> : int array
252  val c = <array> : int array
253  val slice00 = <slice> : int slice
254  val slice01 = <slice> : int slice
255  val slice02 = <slice> : int slice
256  val slice03 = <slice> : int slice
257  val slice04 = <slice> : int slice
258  val slice05 = <slice> : int slice
259  val slicea07 = <slice> : int slice
260  val slicea02 = <slice> : int slice
261  val slicea23 = <slice> : int slice
262  val slicea25 = <slice> : int slice
263  val slice06 = <slice> : int slice
264  val slice07 = <slice> : int slice
265  val slice08 = <slice> : int slice
266  val slice09 = <slice> : int slice
267  val slice0s =
268    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
269     <slice>, <slice>] : int slice list
270  val sliceas = [<slice>, <slice>, <slice>, <slice>] : int slice list
271  val test1a = "OK" : string
272  val test1b = "OK" : string
273  val test2a = "OK" : string
274  val test2b = "OK" : string
275  val test2c = "OK" : string
276  val test2d = "OK" : string
277  val test2e = "OK" : string
278  val test3a = "OK" : string
279  val test4a = "OK" : string
280  val test4b = "OK" : string
281  val test4c = "OK" : string
282  val test4d = "OK" : string
283  val test4e = "OK" : string
284  val test4f = "OK" : string
285  val test4g = "OK" : string
286  val test5 = "OK" : string
287  val test6a = "OK" : string
288  val test6b = "OK" : string
289  val test6c = "OK" : string
290  val sliced = <slice> : int slice
291  val sliceb = <slice> : int slice
292  val e = <array> : int array
293  val ev =
294    #[1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41,
295      51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
296      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
297      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
298      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
299      41, 51, 61, 1, 11, 441, 551, 661, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
300      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
301      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
302      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
303      41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11,
304      21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, ...] : int vector
305  val slicee = <slice> : int slice
306  val test9a = "OK" : string
307  val test9b = "OK" : string
308  val g = <array> : int array
309  val sliceg = <slice> : int slice
310  val test10a = "OK" : string
311  val sliceg0 = <slice> : int slice
312  val test10b = "OK" : string
313  val sliceg1 = <slice> : int slice
314  val test10c = "OK" : string
315  val sliceg202 = <slice> : int slice
316  val test10d = "OK" : string
317  val test11a = "OK" : string
318  val test11b = "OK" : string
319  val test11c = "OK" : string
320  val test12a = "OK" : string
321  val test12b = "OK" : string
322  val test12c = "OK" : string
323  val test12d = "OK" : string
324  val test12e = "OK" : string
325  val test12f = "OK" : string
326  val test12g = "OK" : string
327  val test12h = "OK" : string
328  val test12i = "OK" : string
329  val test13 = "OK" : string
330  val test14a = "OK" : string
331  val test14b = "OK" : string
332  val test15 = "OK" : string
333  val test16 = "OK" : string
334  val test17a = "OK" : string
335  val test17b = "OK" : string
336[closing file "arrayslice.sml"]
337[opening file "arraysort.sml"]
338> val it = () : unit
339> val it = () : unit
340> val it = () : unit
341> val a = <array> : real array
342> val test1 = true : bool
343> val test2 = true : bool
344[closing file "arraysort.sml"]
345[opening file "bytechar.sml"]
346[opening file "auxil.sml"]
347> infix 1 seq
348  val ('a, 'b) seq = fn : 'a * 'b -> 'b
349> val check = fn : bool -> string
350> val check' = fn : (unit -> bool) -> string
351> val range = fn : int * int -> (int -> bool) -> bool
352> val checkrange = fn : int * int -> (int -> bool) -> string
353[closing file "auxil.sml"]
354> val it = () : unit
355> val test1 = "OK" : string
356  val test2 = "OK" : string
357  val test3 = "OK" : string
358  val test4 = "OK" : string
359  val test5 = "OK" : string
360  val test6 = "OK" : string
361  val test7 = "OK" : string
362  val test8 = "OK" : string
363  val test9 = "OK" : string
364  val test10a = "OK" : string
365  val test10b = "OK" : string
366  val test10c = "OK" : string
367  val test10d = "OK" : string
368  val test10e = "OK" : string
369  val test10f = "OK" : string
370  val test10g = "OK" : string
371  val test10h = "OK" : string
372  val test10i = "OK" : string
373  val test10j = "OK" : string
374  val test11a = "OK" : string
375  val test11b = "OK" : string
376  val test11c = "OK" : string
377  val test11d = "OK" : string
378  val test11e = "OK" : string
379  val test11f = "OK" : string
380  val test11g = "OK" : string
381  val test11h = "OK" : string
382  val test11i = "OK" : string
383  val test11j = "OK" : string
384  val test18 = "OK" : string
385  val test19 = "OK" : string
386  val test20 = "OK" : string
387  val test21 = "OK" : string
388  val test22 = "OK" : string
389  val test23 = "OK" : string
390  val test24 = "OK" : string
391  val test25 = "OK" : string
392  val test26 = "OK" : string
393  val test27 = "OK" : string
394  val test28 = "OK" : string
395  val test29 = "OK" : string
396  val test30 = "OK" : string
397  val test31 = "OK" : string
398  val test32 = "OK" : string
399  val test33 = "OK" : string
400  val test34a = "OK" : string
401  val test34b = "OK" : string
402  val test35a = "OK" : string
403  val test35b = "OK" : string
404  val test36 = "OK" : string
405  val test37 = "OK" : string
406  val test38 = "OK" : string
407  val test39 = "OK" : string
408  val test40 = "OK" : string
409  val test41 = "OK" : string
410  val test42 = "OK" : string
411  val test43 = "OK" : string
412[closing file "bytechar.sml"]
413[opening file "callback.sml"]
414[opening file "auxil.sml"]
415> infix 1 seq
416  val ('a, 'b) seq = fn : 'a * 'b -> 'b
417> val check = fn : bool -> string
418> val check' = fn : (unit -> bool) -> string
419> val range = fn : int * int -> (int -> bool) -> bool
420> val checkrange = fn : int * int -> (int -> bool) -> string
421[closing file "auxil.sml"]
422> val it = () : unit
423> val it = () : unit
424> val test1a = "OK" : string
425  val test1b = "OK" : string
426  val test1c = "OK" : string
427  val test1d = "OK" : string
428  val test2a = "OK" : string
429  val test3a = "OK" : string
430[closing file "callback.sml"]
431[opening file "date.sml"]
432[opening file "auxil.sml"]
433> infix 1 seq
434  val ('a, 'b) seq = fn : 'a * 'b -> 'b
435> val check = fn : bool -> string
436> val check' = fn : (unit -> bool) -> string
437> val range = fn : int * int -> (int -> bool) -> bool
438> val checkrange = fn : int * int -> (int -> bool) -> string
439[closing file "auxil.sml"]
440> val it = () : unit
441This is (local time) now:        Sun May  6 21:50:35 2007
442This is UTC now:                 Sun May  6 19:50:35 2007
443This is an hour from now:        Sun May  6 22:50:35 2007
444This is a day from now:          Mon May  7 21:50:35 2007
445This is a week from now:         Sun May 13 21:50:35 2007
446This is 120 days from now:       Mon Sep  3 21:50:35 2007
447This is 160 days from now:       Sat Oct 13 21:50:35 2007
448This is 200 days from now:       Thu Nov 22 20:50:35 2007
449This is 240 days from now:       Tue Jan  1 20:50:35 2008
450This is the epoch (UTC):         Thu Jan  1 00:00:00 1970
451The UTC millenium (UTC time):    Sat Jan  1 00:00:00 2000
452The UTC millenium (UTC time):    Sat Jan  1 00:00:00 2000
453The UTC millenium minus 5 sec:   Fri Dec 31 23:59:55 1999
454The UTC millenium (local time):  Sat Jan  1 01:00:00 2000
455The local millenium (UTC time):  Fri Dec 31 23:00:00 1999
456The UTC+01 millenium (UTC):      Fri Dec 31 23:00:00 1999
457The UTC-01 millenium (UTC):      Sat Jan  1 01:00:00 2000
458This is today's number:          126 (internally: 125)
459This is today's weekday:         Sunday
460This is the name of this month:  May
461Today's ISO date:                2007-05-06
462> val test1 = "OK" : string
463  val test2 = "OK" : string
464  val test3 = "OK" : string
465  val test4 = "OK" : string
466  val test5 = "OK" : string
467  val test6 = "OK" : string
468  val addh = fn : int -> month * int * int
469  val test7 = "OK" : string
470  val test8 = "OK" : string
471  val test9 = "OK" : string
472[closing file "date.sml"]
473[opening file "filesys.sml"]
474[opening file "auxil.sml"]
475> infix 1 seq
476  val ('a, 'b) seq = fn : 'a * 'b -> 'b
477> val check = fn : bool -> string
478> val check' = fn : (unit -> bool) -> string
479> val range = fn : int * int -> (int -> bool) -> bool
480> val checkrange = fn : int * int -> (int -> bool) -> string
481[closing file "auxil.sml"]
482> val it = () : unit
483> val test1a = "OK" : string
484  val test1b = "OK" : string
485  val test2 = "OK" : string
486  val test3a = "OK" : string
487  val test4a = "OK" : string
488  val test4b = "OK" : string
489  val test4c = "OK" : string
490  val test4d = "OK" : string
491  val test5 = "OK" : string
492  val test6a = "OK" : string
493  val test6b = "OK" : string
494  val test6c = "OK" : string
495  val test6d = "OK" : string
496  val test6e = "OK" : string
497  val test6f = "OK" : string
498  val test6g = "OK" : string
499  val test6h = "OK" : string
500  val test6i = "OK" : string
501  val test6j = "OK" : string
502  val test6k = "OK" : string
503  val test6l = "OK" : string
504  val test7a = "OK" : string
505  val test7b = "OK" : string
506  val test7c = "OK" : string
507  val test7d = "OK" : string
508  val test7e = "OK" : string
509  val test8a = "OK" : string
510  val test8b = "OK" : string
511  val test8c = "OK" : string
512  val test8d = "OK" : string
513  val test8e = "OK" : string
514  val test8f = "OK" : string
515  val test8g = "OK" : string
516  val test8h = "OK" : string
517  val test9a = "OK" : string
518  val test9b = "OK" : string
519  val test10a = "OK" : string
520  val test10b = "OK" : string
521  val test10c = "OK" : string
522  val test11a = "OK" : string
523  val test11b = "OK" : string
524  val test11c = "OK" : string
525  val test12a = "OK" : string
526  val test12b = "OK" : string
527  val test12c = "OK" : string
528  val test13a = "OK" : string
529  val test13b = "OK" : string
530  val test13c = "OK" : string
531  val test13d = "OK" : string
532  val test13e = "OK" : string
533  val test14 = "OK" : string
534  val test15a = "OK" : string
535  val test15b = "OK" : string
536  val test15c = "OK" : string
537  val test15d = "OK" : string
538  val test15e = "OK" : string
539  val test15f = "OK" : string
540[closing file "filesys.sml"]
541[opening file "general.sml"]
542[opening file "auxil.sml"]
543> infix 1 seq
544  val ('a, 'b) seq = fn : 'a * 'b -> 'b
545> val check = fn : bool -> string
546> val check' = fn : (unit -> bool) -> string
547> val range = fn : int * int -> (int -> bool) -> bool
548> val checkrange = fn : int * int -> (int -> bool) -> string
549[closing file "auxil.sml"]
550> val it = () : unit
551> exn NoExceptionRaised = NoExceptionRaised : exn
552  val 'a getExn = fn : (unit -> 'a) -> exn
553  val prExn = fn : string * exn -> unit
554> exn E1 = E1 : exn
555> exn E2 = E2 : exn
556File "general.sml", line 20, characters 42-46:
557!      ("Bind",      getExn(fn _ => let val true = false in () end)),
558!                                           ^^^^
559! Warning: pattern matching is not exhaustive
560
561File "general.sml", line 21, characters 35-48:
562!      ("Match",     getExn(fn _ => (fn true => ()) false)),
563!                                    ^^^^^^^^^^^^^
564! Warning: pattern matching is not exhaustive
565Should be `E1 or E2':
566  E1
567  E1
568Should be `Bind':
569  Bind
570  Bind
571Should be `Match':
572  Match
573  Match
574Should be `Subscript':
575  Subscript
576  Subscript
577Should be `Size':
578  Size
579  Size
580Should be `Div':
581  Div
582  Div
583Should be `Chr':
584  Chr
585  Chr
586Should be `Fail':
587  Fail
588  Fail: demo
589Should be `Option':
590  Option
591  Option
592Should be `Empty':
593  Empty
594  Empty
595Should be `SysErr':
596  SysErr
597  SysErr: modTime failed on `exists.not': No such file or directory
598Should be `Io':
599  Io
600  Io: openOut failed on `.'; SysErr: Is a directory
601
602[closing file "general.sml"]
603[opening file "int.sml"]
604[opening file "auxil.sml"]
605> infix 1 seq
606  val ('a, 'b) seq = fn : 'a * 'b -> 'b
607> val check = fn : bool -> string
608> val check' = fn : (unit -> bool) -> string
609> val range = fn : int * int -> (int -> bool) -> bool
610> val checkrange = fn : int * int -> (int -> bool) -> string
611[closing file "auxil.sml"]
612> val it = () : unit
613> val test1a = "OK" : string
614  val test1b = "OK" : string
615  val test1c = "OK" : string
616  val test1d = "OK" : string
617  val test2a = "OK" : string
618  val test2b = "OK" : string
619  val test2c = "OK" : string
620  val test2d = "OK" : string
621  val test3 = "OK" : string
622  val test4 = "OK" : string
623  val test5 = "OK" : string
624  val test6 = "OK" : string
625  val test12 = "OK" : string
626  val ('a, ''b) chk = fn : ('a -> ''b option) -> 'a * ''b -> string
627  val chkScan = fn : radix -> string * int -> string
628  val test13a =
629    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
630     "OK", "OK"] : string list
631  val test13b =
632    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
633  string list
634  val test14a =
635    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
636     "OK", "OK"] : string list
637  val test14b =
638    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
639  string list
640  val test15a =
641    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
642     "OK", "OK"] : string list
643  val test15b =
644    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
645     "OK", "OK"] : string list
646  val test16a =
647    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
648     "OK", "OK"] : string list
649  val test16b =
650    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
651     "OK"] : string list
652  val test17a =
653    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
654     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
655     "OK"] : string list
656  val test17b =
657    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
658  string list
659  val test18 = "OK" : string
660  val test19 = "OK" : string
661  val test20 = "OK" : string
662  val test21 = "OK" : string
663  val test22 = "OK" : string
664[closing file "int.sml"]
665[opening file "list.sml"]
666[opening file "auxil.sml"]
667> infix 1 seq
668  val ('a, 'b) seq = fn : 'a * 'b -> 'b
669> val check = fn : bool -> string
670> val check' = fn : (unit -> bool) -> string
671> val range = fn : int * int -> (int -> bool) -> bool
672> val checkrange = fn : int * int -> (int -> bool) -> string
673[closing file "auxil.sml"]
674> val it = () : unit
675> val v123 = [1, 2, 3] : int list
676  val even = fn : int -> bool
677  val test1 = "OK" : string
678  val test2 = "OK" : string
679  val test3 = "OK" : string
680  val test4 = "OK" : string
681  val test5 = "OK" : string
682  val test6 = "OK" : string
683  val test7 = "OK" : string
684  val test8 = "OK" : string
685  val test9 = "OK" : string
686  val test10 = "OK" : string
687  val v16 = [1, 2, 3, 4, 5, 6] : int list
688  val test11 = "OK" : string
689  val test12 = "OK" : string
690  val test13 = "OK" : string
691  val reset = fn : unit -> unit
692  val incrv = fn : int -> unit
693  val checkv = fn : unit -> string
694  val test14 = fn : unit -> string
695  val test15a = "OK" : string
696  val test15b = fn : unit -> string
697  val test16 = "OK" : string
698  val test17 = "OK" : string
699  val test18 = "OK" : string
700  val test19 = "OK" : string
701  val test20 = "OK" : string
702  val test21 = "OK" : string
703  val test22 = "OK" : string
704  val test23 = "OK" : string
705  val test24 = "OK" : string
706  val test25 = "OK" : string
707  val test26 = "OK" : string
708  val test27 = "OK" : string
709  val test28 = "OK" : string
710  val test29 = "OK" : string
711  val test30 = "OK" : string
712  val test31 = "OK" : string
713  val test32 = "OK" : string
714  val test33 = "OK" : string
715  val test34 = "OK" : string
716  val test35a = "OK" : string
717  val test35b = "OK" : string
718  val test35c = "OK" : string
719  val test36a = "OK" : string
720  val test36b = "OK" : string
721  val test36c = "OK" : string
722  val test37a = "OK" : string
723  val test38 = "OK" : string
724[closing file "list.sml"]
725[opening file "listpair.sml"]
726[opening file "auxil.sml"]
727> infix 1 seq
728  val ('a, 'b) seq = fn : 'a * 'b -> 'b
729> val check = fn : bool -> string
730> val check' = fn : (unit -> bool) -> string
731> val range = fn : int * int -> (int -> bool) -> bool
732> val checkrange = fn : int * int -> (int -> bool) -> string
733[closing file "auxil.sml"]
734> val it = () : unit
735> val test1 = "OK" : string
736  val test2a = "OK" : string
737  val test2b = "OK" : string
738  val reset = fn : unit -> unit
739  val incrv = fn : int -> unit
740  val checkv = fn : unit -> string
741  val checkv6 = fn : unit -> string
742  val checkv0 = fn : unit -> string
743  val test3a = "OK" : string
744  val test3b = "OK" : string
745  val test4 = "OK" : string
746  val test5a = "OK" : string
747  val test5b = "OK" : string
748  val test5c = "OK" : string
749  val test5d = "OK" : string
750  val test5e = "OK" : string
751  val test6 = "OK" : string
752  val test7 = "OK" : string
753  val test8a = "OK" : string
754  val test8b = "OK" : string
755  val test9a = "OK" : string
756  val test9b = "OK" : string
757  val test9c = "OK" : string
758  val test9d = "OK" : string
759  val test9e = "OK" : string
760  val test10a = "OK" : string
761  val test10b = "OK" : string
762  val test10c = "OK" : string
763  val test10d = "OK" : string
764  val test11a = "OK" : string
765  val test11b = "OK" : string
766  val test11c = "OK" : string
767  val test12a = "OK" : string
768  val test12b = "OK" : string
769  val test13a = "OK" : string
770  val test13b = "OK" : string
771  val test13c = "OK" : string
772[closing file "listpair.sml"]
773[opening file "listsort.sml"]
774> val it = () : unit
775[opening file "auxil.sml"]
776> infix 1 seq
777  val ('a, 'b) seq = fn : 'a * 'b -> 'b
778> val check = fn : bool -> string
779> val check' = fn : (unit -> bool) -> string
780> val range = fn : int * int -> (int -> bool) -> bool
781> val checkrange = fn : int * int -> (int -> bool) -> string
782[closing file "auxil.sml"]
783> val it = () : unit
784> val test1r = "OK" : string
785  val test1i = "OK" : string
786  val test2r = "OK" : string
787  val test2i = "OK" : string
788  val test3r = "OK" : string
789  val test3i = "OK" : string
790  val 'a double = fn : 'a list -> 'a list
791  val test4 = "OK" : string
792  val test5 = "OK" : string
793  val inteqccheck = fn :
794  (int * int -> order) -> int list -> int list list -> bool
795  val f = fn : int list * int list list -> bool
796  val test6 = "OK" : string
797[closing file "listsort.sml"]
798[opening file "math.sml"]
799[opening file "auxil.sml"]
800> infix 1 seq
801  val ('a, 'b) seq = fn : 'a * 'b -> 'b
802> val check = fn : bool -> string
803> val check' = fn : (unit -> bool) -> string
804> val range = fn : int * int -> (int -> bool) -> bool
805> val checkrange = fn : int * int -> (int -> bool) -> string
806[closing file "auxil.sml"]
807> val it = () : unit
808> val test0a = "OK" : string
809  val test0b = "OK" : string
810  val test1a = "OK" : string
811  val test1b = "OK" : string
812  val test1c = "OK" : string
813  val test2a = "OK" : string
814  val test2b = "OK" : string
815  val test2c = "OK" : string
816  val test2d = "OK" : string
817  val test3a = "OK" : string
818  val test3b = "OK" : string
819  val test3c = "OK" : string
820  val test3d = "OK" : string
821  val test4a = "OK" : string
822  val test4b = "OK" : string
823  val test4c = "OK" : string
824  val test4d = "OK" : string
825  val test4e = "OK" : string
826  val test4f = "OK" : string
827  val test4g = "OK" : string
828  val test5a = "OK" : string
829  val test5b = "OK" : string
830  val test5c = "OK" : string
831  val test5d = "OK" : string
832  val test5e = "OK" : string
833  val test6a = "OK" : string
834  val test6b = "OK" : string
835  val test6c = "OK" : string
836  val test6d = "OK" : string
837  val test6e = "OK" : string
838  val test7a = "OK" : string
839  val test7b = "OK" : string
840  val test7c = "OK" : string
841  val test7d = "OK" : string
842  val test7e = "OK" : string
843  val test8a = "OK" : string
844  val test8b = "OK" : string
845  val test8c = "OK" : string
846  val test8d = "OK" : string
847  val test8e = "OK" : string
848  val test8f = "OK" : string
849  val test8g = "OK" : string
850  val test8h = "OK" : string
851  val test8i = "OK" : string
852  val test8j = "OK" : string
853  val test8k = "OK" : string
854  val test8l = "OK" : string
855  val test9a = "OK" : string
856  val test9b = "OK" : string
857  val test9c = "OK" : string
858  val test10a = "OK" : string
859  val test10b = "OK" : string
860  val test10c = "OK" : string
861  val test10d = "OK" : string
862  val test10e = "OK" : string
863  val test12a = "OK" : string
864  val test12b = "OK" : string
865  val test12c = "OK" : string
866  val test12d = "OK" : string
867  val test12e = "OK" : string
868  val test12f = "OK" : string
869  val test12g = "OK" : string
870  val test12h = "OK" : string
871  val test12i = "OK" : string
872  val test12j = "OK" : string
873  val test12k = "OK" : string
874  val test12l = "OK" : string
875  val test12m = "OK" : string
876  val test13a = "OK" : string
877  val test13b = "OK" : string
878  val test13c = "OK" : string
879  val test13d = "OK" : string
880  val test13e = "OK" : string
881  val check14a = "OK" : string
882  val check14b = "OK" : string
883  val check14c = "OK" : string
884  val check14d = "OK" : string
885  val check14e = "OK" : string
886  val check15a = "OK" : string
887  val check15b = "OK" : string
888  val check15c = "OK" : string
889  val check15d = "OK" : string
890  val check15e = "OK" : string
891  val check15f = "OK" : string
892  val check15g = "OK" : string
893[closing file "math.sml"]
894[opening file "mosml.sml"]
895[opening file "auxil.sml"]
896> infix 1 seq
897  val ('a, 'b) seq = fn : 'a * 'b -> 'b
898> val check = fn : bool -> string
899> val check' = fn : (unit -> bool) -> string
900> val range = fn : int * int -> (int -> bool) -> bool
901> val checkrange = fn : int * int -> (int -> bool) -> string
902[closing file "auxil.sml"]
903> val it = () : unit
904> val test1 = "OK" : string
905  val test2 = "OK" : string
906  val test3 = "OK" : string
907  val test4 = "OK" : string
908  val test5a = "OK" : string
909  val test5b = "OK" : string
910[closing file "mosml.sml"]
911[opening file "polyhash.sml"]
912> val it = () : unit
913[opening file "auxil.sml"]
914> infix 1 seq
915  val ('a, 'b) seq = fn : 'a * 'b -> 'b
916> val check = fn : bool -> string
917> val check' = fn : (unit -> bool) -> string
918> val range = fn : int * int -> (int -> bool) -> bool
919> val checkrange = fn : int * int -> (int -> bool) -> string
920[closing file "auxil.sml"]
921> val it = () : unit
922> New type names: =reflist
923  val test1 = "OK" : string
924  val test2 = "OK" : string
925  val test3 = "OK" : string
926  val mkstr = fn : int -> string -> string
927  val equal = fn : string -> int -> bool
928  val unequal = fn : string -> int -> bool
929  val blank128 =
930    "                                                                                                                                "
931     : string
932  val test4 = "OK" : string
933  val test5 = "OK" : string
934  val test6 = "OK" : string
935  val test7 = "OK" : string
936  val t = <hash_table> : (int, string) hash_table
937  val test8 = "OK" : string
938  val test9 = "OK" : string
939  val test10 = "OK" : string
940[closing file "polyhash.sml"]
941[opening file "process.sml"]
942[opening file "auxil.sml"]
943> infix 1 seq
944  val ('a, 'b) seq = fn : 'a * 'b -> 'b
945> val check = fn : bool -> string
946> val check' = fn : (unit -> bool) -> string
947> val range = fn : int * int -> (int -> bool) -> bool
948> val checkrange = fn : int * int -> (int -> bool) -> string
949[closing file "auxil.sml"]
950> val it = () : unit
951sh: nonsuchprogramexists: command not found
952> val test1 = "OK" : string
953  val test2 = "OK" : string
954  val test3a = "OK" : string
955  val test3b = "OK" : string
956  val test3c = "OK" : string
957  val test4 = "OK" : string
958[closing file "process.sml"]
959[opening file "random.sml"]
960[opening file "auxil.sml"]
961> infix 1 seq
962  val ('a, 'b) seq = fn : 'a * 'b -> 'b
963> val check = fn : bool -> string
964> val check' = fn : (unit -> bool) -> string
965> val range = fn : int * int -> (int -> bool) -> bool
966> val checkrange = fn : int * int -> (int -> bool) -> string
967[closing file "auxil.sml"]
968> val it = () : unit
969> val it = () : unit
970> val r42 = fn : generator -> int
971  val rmax = fn : generator -> int
972  val rlo = fn : generator -> int
973  val rhi = fn : generator -> int
974  val test1a = "OK" : string
975  val test1b = "OK" : string
976  val test1c = "OK" : string
977  val test1d = "OK" : string
978  val test1e = "OK" : string
979  val rl42 = fn : int * generator -> int list
980  val rlmax = fn : int * generator -> int list
981  val rllo = fn : int * generator -> int list
982  val rlhi = fn : int * generator -> int list
983  val test2a = "OK" : string
984  val test2b = "OK" : string
985  val test2c = "OK" : string
986  val test2d = "OK" : string
987  val test2e = "OK" : string
988  val rl8 = fn : int * generator -> int list
989  val test3a = "OK" : string
990[closing file "random.sml"]
991[opening file "real.sml"]
992[opening file "auxil.sml"]
993> infix 1 seq
994  val ('a, 'b) seq = fn : 'a * 'b -> 'b
995> val check = fn : bool -> string
996> val check' = fn : (unit -> bool) -> string
997> val range = fn : int * int -> (int -> bool) -> bool
998> val checkrange = fn : int * int -> (int -> bool) -> string
999[closing file "auxil.sml"]
1000> val it = () : unit
1001> val test1 = "OK" : string
1002  val test2 = "OK" : string
1003  val test3 = "OK" : string
1004  val test4a = "OK" : string
1005  val test4b = "OK" : string
1006  val test4c = ["OK", "OK"] : string list
1007  val test5a = "OK" : string
1008  val test5b = "OK" : string
1009  val test5c = ["OK", "OK"] : string list
1010  val test6a = "OK" : string
1011  val test6b = "OK" : string
1012  val test6c = ["OK", "OK"] : string list
1013  val test7a = "OK" : string
1014  val test7b = fn : real list -> string
1015  val test7c = ["OK", "OK"] : string list
1016  val test8 = "OK" : string
1017  val chk = fn : string * real -> string
1018  val test9a = ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1019  string list
1020  val test9b =
1021    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1022     "OK"] : string list
1023  val test9c =
1024    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1025  string list
1026  val test9d =
1027    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1028  string list
1029  val test9e =
1030    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1031  string list
1032  val test9f =
1033    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1034  string list
1035  val test9g =
1036    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1037  string list
1038  val test9h =
1039    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1040  string list
1041  val test9i =
1042    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1043  string list
1044  val test9j =
1045    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1046  string list
1047  val test10 = ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
1048  val test11a = "OK" : string
1049  val test11b = "OK" : string
1050  val chkFIX = fn : real * string * string * string * string -> bool
1051  val chkFIX' = fn : real * string * string * string * string -> bool
1052  val test11c = "OK" : string
1053  val test12a = "OK" : string
1054  val test12b = "OK" : string
1055  val chkSCI = fn : real * string * string * string * string -> bool
1056  val chkSCI' = fn : real * string * string * string * string -> bool
1057  val test12c = "OK" : string
1058  val test13a = "OK" : string
1059  val test13b = "OK" : string
1060  val chkGEN = fn : real * string * string * string * string -> bool
1061  val chkGEN' = fn : real * string * string * string * string -> bool
1062  val test13c = "OK" : string
1063[closing file "real.sml"]
1064[opening file "string.sml"]
1065[opening file "auxil.sml"]
1066> infix 1 seq
1067  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1068> val check = fn : bool -> string
1069> val check' = fn : (unit -> bool) -> string
1070> val range = fn : int * int -> (int -> bool) -> bool
1071> val checkrange = fn : int * int -> (int -> bool) -> string
1072[closing file "auxil.sml"]
1073> val it = () : unit
1074> val test1 = "OK" : string
1075  val test2 = "OK" : string
1076  val test3 = "OK" : string
1077  val test4 = "OK" : string
1078  val test5 = "OK" : string
1079  val test6a = "OK" : string
1080  val test6b = "OK" : string
1081  val test7 = "OK" : string
1082  val test8 = "OK" : string
1083  val test9 = "OK" : string
1084  val test10 = "OK" : string
1085  val test11a = "OK" : string
1086  val test11b = "OK" : string
1087  val test11c = "OK" : string
1088  val test11d = "OK" : string
1089  val test11e = "OK" : string
1090  val test11f = "OK" : string
1091  val test11g = "OK" : string
1092  val test11h = "OK" : string
1093  val test12a = "OK" : string
1094  val test12b = "OK" : string
1095  val test12c = "OK" : string
1096  val test12d = "OK" : string
1097  val test12e = "OK" : string
1098  val test12f = "OK" : string
1099  val test12g = "OK" : string
1100  val test12'a = "OK" : string
1101  val test12'b = "OK" : string
1102  val test13a = "OK" : string
1103  val test13b = "OK" : string
1104  val test14 = "OK" : string
1105  val test15 = "OK" : string
1106  val test16a = "OK" : string
1107  val test16b = "OK" : string
1108  val test17 = "OK" : string
1109  val test18 = "OK" : string
1110  val test19 = "OK" : string
1111  val test20 = "OK" : string
1112  val test21 = "OK" : string
1113  val test22 = "OK" : string
1114  val test23 = "OK" : string
1115  val test24 = "OK" : string
1116  val test25 = "OK" : string
1117  val test26 = "OK" : string
1118  val test27 = "OK" : string
1119  val test28 = "OK" : string
1120  val test29 = "OK" : string
1121[closing file "string.sml"]
1122[opening file "stringcvt.sml"]
1123[opening file "auxil.sml"]
1124> infix 1 seq
1125  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1126> val check = fn : bool -> string
1127> val check' = fn : (unit -> bool) -> string
1128> val range = fn : int * int -> (int -> bool) -> bool
1129> val checkrange = fn : int * int -> (int -> bool) -> string
1130[closing file "auxil.sml"]
1131> val it = () : unit
1132> New type names: =result
1133  val test1 = "OK" : string
1134  val test2 = "OK" : string
1135  val test3 = "OK" : string
1136  val test4 = "OK" : string
1137  val test5 = "OK" : string
1138  val test6 = "OK" : string
1139  val test7 = "OK" : string
1140  val test8 = "OK" : string
1141  val test9 = "OK" : string
1142  val test10 = "OK" : string
1143[closing file "stringcvt.sml"]
1144[opening file "substring.sml"]
1145[opening file "auxil.sml"]
1146> infix 1 seq
1147  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1148> val check = fn : bool -> string
1149> val check' = fn : (unit -> bool) -> string
1150> val range = fn : int * int -> (int -> bool) -> bool
1151> val checkrange = fn : int * int -> (int -> bool) -> string
1152[closing file "auxil.sml"]
1153> val it = () : unit
1154> val test1a = "OK" : string
1155  val test1b = "OK" : string
1156  val test1c = "OK" : string
1157  val test1d = "OK" : string
1158  val test1e = "OK" : string
1159  val test1f = "OK" : string
1160  val test1g = "OK" : string
1161  val test1h = "OK" : string
1162  val test2a = "OK" : string
1163  val test2b = "OK" : string
1164  val test2c = "OK" : string
1165  val test3a = "OK" : string
1166  val test3b = "OK" : string
1167  val test3c = "OK" : string
1168  val test4 = "OK" : string
1169  val test5a = "OK" : string
1170  val test5b = "OK" : string
1171  val test6 = "OK" : string
1172  val test7 = "OK" : string
1173  val test8a = "OK" : string
1174  val test8b = "OK" : string
1175  val test8c = "OK" : string
1176  val test8d = "OK" : string
1177  val test8e = "OK" : string
1178  val test8f = "OK" : string
1179  val test9a = "OK" : string
1180  val test9b = "OK" : string
1181  val test9c = "OK" : string
1182  val test9d = "OK" : string
1183  val test9e = "OK" : string
1184  val test9f = "OK" : string
1185  val test9g = "OK" : string
1186  val test9h = "OK" : string
1187  val test12 = "OK" : string
1188  val test13 = "OK" : string
1189  val test14 = "OK" : string
1190  val finda = fn : char -> bool
1191  val findb = fn : char -> bool
1192  val test15 = "OK" : string
1193  val test16 = "OK" : string
1194  val test17 = "OK" : string
1195  val test18 = "OK" : string
1196  val test19 = "OK" : string
1197  val test20 = "OK" : string
1198  val test21 = "OK" : string
1199  val test22a = "OK" : string
1200  val test22b = "OK" : string
1201  val test23 = "OK" : string
1202  val test24 = "OK" : string
1203  val test25 = "OK" : string
1204  val test26a = "OK" : string
1205  val test26b = "OK" : string
1206  val test27a = "OK" : string
1207  val test27b = "OK" : string
1208  val test28 = "OK" : string
1209  val test29a = "OK" : string
1210  val test29b = "OK" : string
1211  val test29c = "OK" : string
1212  val test30a = "OK" : string
1213  val test30b = "OK" : string
1214  val test30c = "OK" : string
1215  val test30d = "OK" : string
1216  val test30e = "OK" : string
1217  val test30f = "OK" : string
1218  val test31a = "OK" : string
1219  val test31b = "OK" : string
1220  val test31c = "OK" : string
1221  val eqspan = fn : substring * substring * substring -> bool
1222  val test32a = "OK" : string
1223  val test32c = "OK" : string
1224  val test32d = "OK" : string
1225  val test32b = "OK" : string
1226  val test33a = "OK" : string
1227  val test33b = "OK" : string
1228  val test34 = "OK" : string
1229[closing file "substring.sml"]
1230[opening file "textio.sml"]
1231[opening file "auxil.sml"]
1232> infix 1 seq
1233  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1234> val check = fn : bool -> string
1235> val check' = fn : (unit -> bool) -> string
1236> val range = fn : int * int -> (int -> bool) -> bool
1237> val checkrange = fn : int * int -> (int -> bool) -> string
1238[closing file "auxil.sml"]
1239> val it = () : unit
1240Two lines of output follow:
12411234  <--- this should read 1234
124212345 <--- this should read 12345
1243Two lines of output follow:
1244abcde <--- this should read abcde
1245abcde <--- this should read abcde
1246> val empty = <outstream> : outstream
1247  val small = <outstream> : outstream
1248  val medium = <outstream> : outstream
1249  val text = <outstream> : outstream
1250  val test1 = "OK" : string
1251  val test2 = "OK" : string
1252  val test3 = "OK" : string
1253  val test4 = "OK" : string
1254  val test5 = "OK" : string
1255  val test6 = "OK" : string
1256  val test7a = "OK" : string
1257  val test7b = "OK" : string
1258  val test7c = "OK" : string
1259  val test8a = "OK" : string
1260  val test8b = "OK" : string
1261  val test8c = "OK" : string
1262  val test8d = "OK" : string
1263  val test8e = "OK" : string
1264  val test8f = "OK" : string
1265  val test9a = "OK" : string
1266  val test9b = "OK" : string
1267  val test9c = "OK" : string
1268  val test9d = "OK" : string
1269  val test9e = "OK" : string
1270  val test9na = "OK" : string
1271  val test9nb = "OK" : string
1272  val test9nc = "OK" : string
1273  val test9nd = "OK" : string
1274  val test9ne = "OK" : string
1275  val test9nf = "OK" : string
1276  val test10 = "OK" : string
1277  val test11 = "OK" : string
1278  val test12a = "OK" : string
1279  val test12b = "OK" : string
1280  val test12c = "OK" : string
1281  val test12d = "OK" : string
1282[closing file "textio.sml"]
1283[opening file "time.sml"]
1284[opening file "auxil.sml"]
1285> infix 1 seq
1286  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1287> val check = fn : bool -> string
1288> val check' = fn : (unit -> bool) -> string
1289> val range = fn : int * int -> (int -> bool) -> bool
1290> val checkrange = fn : int * int -> (int -> bool) -> string
1291[closing file "auxil.sml"]
1292> val it = () : unit
1293> val test1 = "OK" : string
1294  val test2a = "OK" : string
1295  val test2b = "OK" : string
1296  val test3a = "OK" : string
1297  val test4a = "OK" : string
1298  val test6a = "OK" : string
1299  val test7a = "OK" : string
1300  val test8a = "OK" : string
1301  val test9a = "OK" : string
1302  val test9b = "OK" : string
1303  val test9c = "OK" : string
1304  val chk = fn : string * int -> string
1305  val test10a =
1306    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1307     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1308     "OK"] : string list
1309  val test10b = ["OK", "OK", "OK", "OK", "OK", "OK"] : string list
1310[closing file "time.sml"]
1311[opening file "timer.sml"]
1312[opening file "auxil.sml"]
1313> infix 1 seq
1314  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1315> val check = fn : bool -> string
1316> val check' = fn : (unit -> bool) -> string
1317> val range = fn : int * int -> (int -> bool) -> bool
1318> val checkrange = fn : int * int -> (int -> bool) -> string
1319[closing file "auxil.sml"]
1320> val it = () : unit
1321
1322Each line below should show roughly the same User, System, and Gc times:
1323User: 0.040  System: 0.000  Gc: 0.000  Real: 0.041
1324User: 0.044  System: 0.000  Gc: 0.000  Real: 0.042
1325User: 0.044  System: 0.000  Gc: 0.000  Real: 0.042
1326User: 0.040  System: 0.000  Gc: 0.000  Real: 0.042
1327User: 0.044  System: 0.000  Gc: 0.000  Real: 0.042
1328User: 0.040  System: 0.000  Gc: 0.000  Real: 0.042
1329User: 0.044  System: 0.000  Gc: 0.000  Real: 0.042
1330User: 0.040  System: 0.000  Gc: 0.000  Real: 0.042
1331> val test1 = "OK" : string
1332  val test2 = "OK" : string
1333  val test3 = "OK" : string
1334  val ctmr = <cpu_timer> : cpu_timer
1335  val test4 = "OK" : string
1336[closing file "timer.sml"]
1337[opening file "unixpath.sml"]
1338[opening file "auxil.sml"]
1339> infix 1 seq
1340  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1341> val check = fn : bool -> string
1342> val check' = fn : (unit -> bool) -> string
1343> val range = fn : int * int -> (int -> bool) -> bool
1344> val checkrange = fn : int * int -> (int -> bool) -> string
1345[closing file "auxil.sml"]
1346> val it = () : unit
1347> val test1a = "OK" : string
1348  val test1b = "OK" : string
1349  val test1c = "OK" : string
1350  val test1d = "OK" : string
1351  val test1e = "OK" : string
1352  val test1f = "OK" : string
1353  val test1g = "OK" : string
1354  val test1h = "OK" : string
1355  val test1i = "OK" : string
1356  val test1j = "OK" : string
1357  val test1k = "OK" : string
1358  val test1l = "OK" : string
1359  val test1m = "OK" : string
1360  val test1n = "OK" : string
1361  val test2a = "OK" : string
1362  val test2b = "OK" : string
1363  val test2c = "OK" : string
1364  val test2d = "OK" : string
1365  val test2e = "OK" : string
1366  val test2f = "OK" : string
1367  val test2g = "OK" : string
1368  val test2h = "OK" : string
1369  val test2i = "OK" : string
1370  val test2j = "OK" : string
1371  val test2k = "OK" : string
1372  val test2l = "OK" : string
1373  val test2m = "OK" : string
1374  val test2n = "OK" : string
1375  val test2o = "OK" : string
1376  val test2p = "OK" : string
1377  val test3b = "OK" : string
1378  val test3c = "OK" : string
1379  val test3d = "OK" : string
1380  val test3e = "OK" : string
1381  val test3f = "OK" : string
1382  val test3g = "OK" : string
1383  val test3h = "OK" : string
1384  val test4a = "OK" : string
1385  val test4b = "OK" : string
1386  val test5a = "OK" : string
1387  val test6a = "OK" : string
1388  val test6b = "OK" : string
1389  val mka = fn : string * string -> string
1390  val test7a = "OK" : string
1391  val test7b = "OK" : string
1392  val test7c = "OK" : string
1393  val mkr = fn : string * string -> string
1394  val test8a = "OK" : string
1395  val test8b = "OK" : string
1396  val test8c = "OK" : string
1397  val test9a = "OK" : string
1398  val test10a = "OK" : string
1399  val test11a = "OK" : string
1400  val test12 = "OK" : string
1401  val test13 = "OK" : string
1402  val test14 = "OK" : string
1403  val test15 = "OK" : string
1404  val test16 = "OK" : string
1405  val test17 = "OK" : string
1406  val test18 = "OK" : string
1407  val test19 = "OK" : string
1408[closing file "unixpath.sml"]
1409[opening file "vector.sml"]
1410[opening file "auxil.sml"]
1411> infix 1 seq
1412  val ('a, 'b) seq = fn : 'a * 'b -> 'b
1413> val check = fn : bool -> string
1414> val check' = fn : (unit -> bool) -> string
1415> val range = fn : int * int -> (int -> bool) -> bool
1416> val checkrange = fn : int * int -> (int -> bool) -> string
1417[closing file "auxil.sml"]
1418> val it = () : unit
1419! Warning: Value polymorphism:
1420! Free type variable(s) at top level in value identifier vec0
1421> val a = #[0, 1, 2, 3, 4, 5, 6] : int vector
1422  val b = #[44, 55, 66] : int vector
1423  val c = #[0, 1, 2, 3, 4, 5, 6] : int vector
1424  val vec0 = #[] : 'a vector
1425  val test1 = "OK" : string
1426  val test2 = "OK" : string
1427  val d =
1428    #[0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2,
1429      3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5,
1430      6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1,
1431      2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4,
1432      5, 6, 0, 1] : int vector
1433  val test3 = "OK" : string
1434  val test4a = "OK" : string
1435  val test4b = "OK" : string
1436  val test4c = "OK" : string
1437  val test5 = "OK" : string
1438  val test6a = "OK" : string
1439  val test6b = "OK" : string
1440  val test6c = "OK" : string
1441  val e =
1442    #[0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2,
1443      3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5,
1444      6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1,
1445      2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4,
1446      5, 6, 0, 1, 44, 55, 66, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1,
1447      2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4,
1448      5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0,
1449      1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3,
1450      4, 5, 6, 0, 1, 2, 3, 4, 5, ...] : int vector
1451  val test7 = "OK" : string
1452  val test8 = "OK" : string
1453  val f = #[44, 55, 66] : int vector
1454  val test9 = "OK" : string
1455  val ('b, 'c, ''d) chkiter = fn :
1456  ((int -> 'b) -> 'c -> ''d) -> (int -> 'b) -> 'c -> ''d * int -> string
1457  val ('b, 'c, 'd, ''e) chkiteri = fn :
1458  ((int * 'b -> 'c) -> 'd -> ''e) -> ('b -> 'c) -> 'd -> ''e * int -> string
1459  val ('b, 'c, 'd, 'e, ''f) chkfold = fn :
1460  ((int * 'b -> 'c) -> 'd -> 'e -> ''f) -> (int * 'b -> 'c) -> 'd -> 'e ->
1461  ''f * int -> string
1462  val ('b, 'c, 'd, 'e, 'f, ''g) chkfoldi = fn :
1463  ((int * 'b * 'c -> 'd) -> 'e -> 'f -> ''g) -> ('b * 'c -> 'd) -> 'e -> 'f ->
1464  ''g * int -> string
1465  val test10a = "OK" : string
1466  val test10b = "OK" : string
1467  val test10c = "OK" : string
1468  val test10d = "OK" : string
1469  val test10e = "OK" : string
1470  val test10f = "OK" : string
1471  val test10g = "OK" : string
1472  val test11a = "OK" : string
1473  val test11b = "OK" : string
1474  val test11c = "OK" : string
1475  val test11d = "OK" : string
1476  val test11e = "OK" : string
1477  val test12a = "OK" : string
1478  val test12b = "OK" : string
1479  val test12c = "OK" : string
1480  val test12d = "OK" : string
1481  val test13 = "OK" : string
1482  val test14 = "OK" : string
1483  val test15 = "OK" : string
1484  val test16 = "OK" : string
1485[closing file "vector.sml"]
1486[opening file "vectorslice.sml"]
1487[opening file "auxil.sml"]
1488> infix 1 seq
1489  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1490> val check = fn : bool -> string
1491> val check' = fn : (unit -> bool) -> string
1492> val range = fn : int * int -> (int -> bool) -> bool
1493> val checkrange = fn : int * int -> (int -> bool) -> string
1494[closing file "auxil.sml"]
1495> val it = () : unit
1496> val a = #[1, 11, 21, 31, 41, 51, 61] : int vector
1497  val b = #[441, 551, 661] : int vector
1498  val c = #[1, 11, 21, 31, 41, 51, 61] : int vector
1499  val slice00 = <slice> : int slice
1500  val slice01 = <slice> : int slice
1501  val slice02 = <slice> : int slice
1502  val slice03 = <slice> : int slice
1503  val slice04 = <slice> : int slice
1504  val slice05 = <slice> : int slice
1505  val slicea07 = <slice> : int slice
1506  val slicea02 = <slice> : int slice
1507  val slicea23 = <slice> : int slice
1508  val slicea25 = <slice> : int slice
1509  val slice06 = <slice> : int slice
1510  val slice07 = <slice> : int slice
1511  val slice08 = <slice> : int slice
1512  val slice09 = <slice> : int slice
1513  val slice0s =
1514    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
1515     <slice>, <slice>] : int slice list
1516  val sliceas = [<slice>, <slice>, <slice>, <slice>] : int slice list
1517  val test1a = "OK" : string
1518  val test1b = "OK" : string
1519  val test2a = "OK" : string
1520  val test2b = "OK" : string
1521  val test2c = "OK" : string
1522  val test2d = "OK" : string
1523  val test2e = "OK" : string
1524  val test3a = "OK" : string
1525  val test4a = "OK" : string
1526  val test4b = "OK" : string
1527  val test4c = "OK" : string
1528  val test4d = "OK" : string
1529  val test4e = "OK" : string
1530  val test4f = "OK" : string
1531  val test4g = "OK" : string
1532  val test5 = "OK" : string
1533  val sliced = <slice> : int slice
1534  val sliceb = <slice> : int slice
1535  val e = <array> : int array
1536  val ev =
1537    #[1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41,
1538      51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
1539      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
1540      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
1541      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
1542      41, 51, 61, 1, 11, 441, 551, 661, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21,
1543      31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1,
1544      11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51,
1545      61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31,
1546      41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, 61, 1, 11,
1547      21, 31, 41, 51, 61, 1, 11, 21, 31, 41, 51, ...] : int vector
1548  val slicee = <slice> : int slice
1549  val test9a = "OK" : string
1550  val test9b = "OK" : string
1551  val g = <array> : int array
1552  val sliceg = <slice> : int slice
1553  val test10a = "OK" : string
1554  val sliceg0 = <slice> : int slice
1555  val test10b = "OK" : string
1556  val sliceg1 = <slice> : int slice
1557  val test10c = "OK" : string
1558  val sliceg202 = <slice> : int slice
1559  val test10d = "OK" : string
1560  val test11a = "OK" : string
1561  val test11b = "OK" : string
1562  val test11c = "OK" : string
1563  val test12a = "OK" : string
1564  val test12b = "OK" : string
1565  val test12c = "OK" : string
1566  val test12d = "OK" : string
1567  val test12f = "OK" : string
1568  val test12g = "OK" : string
1569  val test12h = "OK" : string
1570  val test12i = "OK" : string
1571  val test13 = "OK" : string
1572  val test14a = "OK" : string
1573  val test14b = "OK" : string
1574  val test15 = "OK" : string
1575  val test17a = "OK" : string
1576  val test17b = "OK" : string
1577[closing file "vectorslice.sml"]
1578[opening file "weak.sml"]
1579[opening file "auxil.sml"]
1580> infix 1 seq
1581  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1582> val check = fn : bool -> string
1583> val check' = fn : (unit -> bool) -> string
1584> val range = fn : int * int -> (int -> bool) -> bool
1585> val checkrange = fn : int * int -> (int -> bool) -> string
1586[closing file "auxil.sml"]
1587> val it = () : unit
1588test1:
1589test2:
1590test3:
1591test4:
1592test5:
1593test6:
1594test7:
1595test8:
1596/////////////////////////////////////////////////////////////////////////////////////
1597> val a = <array> : int list array
1598  val test1 = "OK" : string
1599  val test2 = "OK" : string
1600  val test3 = "OK" : string
1601  val test4 = "OK" : string
1602  val b = <array> : int array
1603  val test5 = "OK" : string
1604  val c = <array> : string array
1605  val test6 = "OK" : string
1606  val test7 = "OK" : string
1607  val test8 = "OK" : string
1608[closing file "weak.sml"]
1609[opening file "word.sml"]
1610[opening file "auxil.sml"]
1611> infix 1 seq
1612  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1613> val check = fn : bool -> string
1614> val check' = fn : (unit -> bool) -> string
1615> val range = fn : int * int -> (int -> bool) -> bool
1616> val checkrange = fn : int * int -> (int -> bool) -> string
1617[closing file "auxil.sml"]
1618> val it = () : unit
1619> val test1 = "OK" : string
1620  val test3 = "OK" : string
1621  val test5a = "OK" : string
1622  val test5b = "OK" : string
1623  val test6a = "OK" : string
1624  val test6b = "OK" : string
1625  val test7a = "OK" : string
1626  val test7b = "OK" : string
1627  val test8a = "OK" : string
1628  val test8b = "OK" : string
1629  val test8c = "OK" : string
1630  val test8d = "OK" : string
1631  val test8e = "OK" : string
1632  val test8f = "OK" : string
1633  val test8g = "OK" : string
1634  val test8h = "OK" : string
1635  val pwr2 = fn : int -> int
1636  val rwp = fn : int -> int -> int
1637  val test9a = "OK" : string
1638  val test9b = "OK" : string
1639  val test9c = "OK" : string
1640  val test9d = "OK" : string
1641  val test9e = "OK" : string
1642  val test9f = "OK" : string
1643  val test9g = "OK" : string
1644  val test9h = "OK" : string
1645  val test10a = "OK" : string
1646  val test10b = "OK" : string
1647  val test10c = "OK" : string
1648  val test10d = "OK" : string
1649  val test11a = "OK" : string
1650  val test11b = "OK" : string
1651  val test11c = "OK" : string
1652  val test11d = "OK" : string
1653  val test11e = "OK" : string
1654  val test11f = "OK" : string
1655  val test11g = "OK" : string
1656  val test11h = "OK" : string
1657  val test11i = "OK" : string
1658  val test12a = "OK" : string
1659  val test12b = "OK" : string
1660  val test12c = "OK" : string
1661  val test12d = "OK" : string
1662  val test12e = "OK" : string
1663  val test12f = "OK" : string
1664  val test12g = "OK" : string
1665  val test12h = "OK" : string
1666  val test12i = "OK" : string
1667  val test12j = "OK" : string
1668  val test12k = "OK" : string
1669  val test12l = "OK" : string
1670  val test12m = "OK" : string
1671  val test12n = "OK" : string
1672  val test12o = "OK" : string
1673  val test12p = "OK" : string
1674  val test12q = "OK" : string
1675  val test12r = "OK" : string
1676  val test12s = "OK" : string
1677  val 'b chk = fn : ('b -> word option) -> 'b * int -> string
1678  val chkScan = fn : radix -> string * int -> string
1679  val test13a =
1680    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1681     "OK", "OK"] : string list
1682  val test13b =
1683    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1684  string list
1685  val test14a =
1686    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1687     "OK", "OK"] : string list
1688  val test14b =
1689    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1690  string list
1691  val test15a =
1692    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1693     "OK", "OK"] : string list
1694  val test15b =
1695    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1696     "OK", "OK"] : string list
1697  val test16a =
1698    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1699     "OK", "OK"] : string list
1700  val test16b =
1701    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1702     "OK"] : string list
1703  val test17a =
1704    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1705     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
1706  val test17b =
1707    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1708  string list
1709  val test18 = "OK" : string
1710  val test19 = "OK" : string
1711  val test20 = "OK" : string
1712  val test21 = "OK" : string
1713  val test22 = "OK" : string
1714[closing file "word.sml"]
1715[opening file "word8.sml"]
1716[opening file "auxil.sml"]
1717> infix 1 seq
1718  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1719> val check = fn : bool -> string
1720> val check' = fn : (unit -> bool) -> string
1721> val range = fn : int * int -> (int -> bool) -> bool
1722> val checkrange = fn : int * int -> (int -> bool) -> string
1723[closing file "auxil.sml"]
1724> val it = () : unit
1725> val test1 = "OK" : string
1726  val test2 = "OK" : string
1727  val test3 = "OK" : string
1728  val test4 = "OK" : string
1729  val test5a = "OK" : string
1730  val test5b = "OK" : string
1731  val test5c = "OK" : string
1732  val test6a = "OK" : string
1733  val test6b = "OK" : string
1734  val test6c = "OK" : string
1735  val test7a = "OK" : string
1736  val test7b = "OK" : string
1737  val test7c = "OK" : string
1738  val test8a = "OK" : string
1739  val test8b = "OK" : string
1740  val test8c = "OK" : string
1741  val test8d = "OK" : string
1742  val test8e = "OK" : string
1743  val test8f = "OK" : string
1744  val test8g = "OK" : string
1745  val test8h = "OK" : string
1746  val test9a = "OK" : string
1747  val test9b = "OK" : string
1748  val test9c = "OK" : string
1749  val test9d = "OK" : string
1750  val test9e = "OK" : string
1751  val test9f = "OK" : string
1752  val test9g = "OK" : string
1753  val test9h = "OK" : string
1754  val test9i = "OK" : string
1755  val test10a = "OK" : string
1756  val test10b = "OK" : string
1757  val test10c = "OK" : string
1758  val test10d = "OK" : string
1759  val test10e = "OK" : string
1760  val test11a = "OK" : string
1761  val test11b = "OK" : string
1762  val test11c = "OK" : string
1763  val test11d = "OK" : string
1764  val test11e = "OK" : string
1765  val test11f = "OK" : string
1766  val test12a = "OK" : string
1767  val test12b = "OK" : string
1768  val test12c = "OK" : string
1769  val test12d = "OK" : string
1770  val test12e = "OK" : string
1771  val test12f = "OK" : string
1772  val test12g = "OK" : string
1773  val test12h = "OK" : string
1774  val test12i = "OK" : string
1775  val test12j = "OK" : string
1776  val test12k = "OK" : string
1777  val test12l = "OK" : string
1778  val test12m = "OK" : string
1779  val test12n = "OK" : string
1780  val test12o = "OK" : string
1781  val test12p = "OK" : string
1782  val test12q = "OK" : string
1783  val 'b chk = fn : ('b -> word8 option) -> 'b * int -> string
1784  val chkScan = fn : radix -> string * int -> string
1785  val test13a =
1786    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1787     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1788     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
1789  val test13b =
1790    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1791  string list
1792  val test13c = "OK" : string
1793  val test13d = "OK" : string
1794  val test14a =
1795    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1796     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
1797  val test14b =
1798    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1799  string list
1800  val test14c = "OK" : string
1801  val test14d = "OK" : string
1802  val test15a =
1803    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1804     "OK", "OK", "OK"] : string list
1805  val test15b =
1806    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1807     "OK", "OK"] : string list
1808  val test15c = "OK" : string
1809  val test15d = "OK" : string
1810  val test16a =
1811    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1812     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
1813  val test16b =
1814    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1815     "OK"] : string list
1816  val test16c = "OK" : string
1817  val test16d = "OK" : string
1818  val test17a =
1819    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1820     "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK",
1821     "OK", "OK", "OK", "OK", "OK", "OK", "OK"] : string list
1822  val test17b =
1823    ["OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK", "OK"] :
1824  string list
1825  val test17c = "OK" : string
1826  val test17d = "OK" : string
1827  val test18 = "OK" : string
1828  val test19 = "OK" : string
1829  val test20 = "OK" : string
1830  val test21 = "OK" : string
1831  val test22 = "OK" : string
1832[closing file "word8.sml"]
1833[opening file "word8array.sml"]
1834[opening file "auxil.sml"]
1835> infix 1 seq
1836  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1837> val check = fn : bool -> string
1838> val check' = fn : (unit -> bool) -> string
1839> val range = fn : int * int -> (int -> bool) -> bool
1840> val checkrange = fn : int * int -> (int -> bool) -> string
1841[closing file "auxil.sml"]
1842> val it = () : unit
1843> val i2w = fn : int -> word8
1844  val w127 = 0wx7F : word8
1845  val a = <array> : array
1846  val b = <array> : array
1847  val c = <array> : array
1848  val test1 = "OK" : string
1849  val test2 = "OK" : string
1850  val d = <array> : array
1851  val test3 = "OK" : string
1852  val test4a = "OK" : string
1853  val test4b = "OK" : string
1854  val test4c = "OK" : string
1855  val test5a = "OK" : string
1856  val test5b = "OK" : string
1857  val test6a = "OK" : string
1858  val test6b = "OK" : string
1859  val test6c = "OK" : string
1860  val e = <array> : array
1861  val a2v = fn : array -> vector/1
1862  val ev = <vector> : vector/1
1863  val test7 = "OK" : string
1864  val test8a = "OK" : string
1865  val test8b = "OK" : string
1866  val f = <vector> : vector/1
1867  val test9 = "OK" : string
1868  val test9a = "OK" : string
1869  val test9b = "OK" : string
1870  val g = <array> : array
1871  val test10a = "OK" : string
1872  val test10b = "OK" : string
1873  val test10c = "OK" : string
1874  val test10d = "OK" : string
1875  val test10e = "OK" : string
1876  val test11a = "OK" : string
1877  val test11b = "OK" : string
1878  val test11c = "OK" : string
1879  val test11d = "OK" : string
1880  val test11e = "OK" : string
1881  val test12 = "OK" : string
1882  val test13 = "OK" : string
1883  val test14 = "OK" : string
1884  val test15 = "OK" : string
1885[closing file "word8array.sml"]
1886[opening file "word8arrayslice.sml"]
1887[opening file "auxil.sml"]
1888> infix 1 seq
1889  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1890> val check = fn : bool -> string
1891> val check' = fn : (unit -> bool) -> string
1892> val range = fn : int * int -> (int -> bool) -> bool
1893> val checkrange = fn : int * int -> (int -> bool) -> string
1894[closing file "auxil.sml"]
1895> val it = () : unit
1896> val a = <array> : array
1897  val b = <array> : array
1898  val c = <array> : array
1899  val slice00 = <slice> : slice
1900  val slice01 = <slice> : slice
1901  val slice02 = <slice> : slice
1902  val slice03 = <slice> : slice
1903  val slice04 = <slice> : slice
1904  val slice05 = <slice> : slice
1905  val slicea07 = <slice> : slice
1906  val slicea02 = <slice> : slice
1907  val slicea23 = <slice> : slice
1908  val slicea25 = <slice> : slice
1909  val slice06 = <slice> : slice
1910  val slice07 = <slice> : slice
1911  val slice08 = <slice> : slice
1912  val slice09 = <slice> : slice
1913  val slice0s =
1914    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
1915     <slice>, <slice>] : slice list
1916  val sliceas = [<slice>, <slice>, <slice>, <slice>] : slice list
1917  val test1a = "OK" : string
1918  val test1b = "OK" : string
1919  val test2a = "OK" : string
1920  val test2b = "OK" : string
1921  val test2c = "OK" : string
1922  val test2d = "OK" : string
1923  val test2e = "OK" : string
1924  val test3a = "OK" : string
1925  val test4a = "OK" : string
1926  val test4b = "OK" : string
1927  val test4c = "OK" : string
1928  val test4d = "OK" : string
1929  val test4e = "OK" : string
1930  val test4f = "OK" : string
1931  val test4g = "OK" : string
1932  val test5 = "OK" : string
1933  val test6a = "OK" : string
1934  val test6b = "OK" : string
1935  val test6c = "OK" : string
1936  val sliced = <slice> : slice
1937  val sliceb = <slice> : slice
1938  val e = <array> : array
1939  val ev = <vector> : vector/1
1940  val slicee = <slice> : slice
1941  val test9a = "OK" : string
1942  val test9b = "OK" : string
1943  val g = <array> : array
1944  val sliceg = <slice> : slice
1945  val test10a = "OK" : string
1946  val sliceg0 = <slice> : slice
1947  val test10b = "OK" : string
1948  val sliceg1 = <slice> : slice
1949  val test10c = "OK" : string
1950  val sliceg202 = <slice> : slice
1951  val test10d = "OK" : string
1952  val test11a = "OK" : string
1953  val test11b = "OK" : string
1954  val test11c = "OK" : string
1955  val test12a = "OK" : string
1956  val test12b = "OK" : string
1957  val test12c = "OK" : string
1958  val test12d = "OK" : string
1959  val test12e = "OK" : string
1960  val test12f = "OK" : string
1961  val test12g = "OK" : string
1962  val test12h = "OK" : string
1963  val test12i = "OK" : string
1964  val test13 = "OK" : string
1965  val test14a = "OK" : string
1966  val test14b = "OK" : string
1967  val test15 = "OK" : string
1968  val test16 = "OK" : string
1969  val test17a = "OK" : string
1970  val test17b = "OK" : string
1971[closing file "word8arrayslice.sml"]
1972[opening file "word8vector.sml"]
1973[opening file "auxil.sml"]
1974> infix 1 seq
1975  val ('b, 'c) seq = fn : 'b * 'c -> 'c
1976> val check = fn : bool -> string
1977> val check' = fn : (unit -> bool) -> string
1978> val range = fn : int * int -> (int -> bool) -> bool
1979> val checkrange = fn : int * int -> (int -> bool) -> string
1980[closing file "auxil.sml"]
1981> val it = () : unit
1982> val a = <vector> : vector/1
1983  val b = <vector> : vector/1
1984  val c = <vector> : vector/1
1985  val test1 = "OK" : string
1986  val test2 = "OK" : string
1987  val d = <vector> : vector/1
1988  val test3 = "OK" : string
1989  val test4a = "OK" : string
1990  val test4b = "OK" : string
1991  val test4c = "OK" : string
1992  val test5 = "OK" : string
1993  val test6a = "OK" : string
1994  val test6b = "OK" : string
1995  val test6c = "OK" : string
1996  val e = <vector> : vector/1
1997  val test7 = "OK" : string
1998  val test8 = "OK" : string
1999  val f = <vector> : vector/1
2000  val test9 = "OK" : string
2001  val ('b, 'c, ''d) chkiter = fn :
2002  ((word8 -> 'b) -> 'c -> ''d) -> (word8 -> 'b) -> 'c -> ''d * word8 -> string
2003  val ('b, 'c, 'd, ''e) chkiteri = fn :
2004  ((int * 'b -> 'c) -> 'd -> ''e) -> ('b -> 'c) -> 'd -> ''e * int -> string
2005  val ('b, 'c, 'd, 'e, ''f) chkfold = fn :
2006  ((word8 * 'b -> 'c) -> 'd -> 'e -> ''f) -> (word8 * 'b -> 'c) -> 'd -> 'e ->
2007  ''f * word8 -> string
2008  val ('b, 'c, 'd, 'e, 'f, ''g) chkfoldi = fn :
2009  ((int * 'b * 'c -> 'd) -> 'e -> 'f -> ''g) -> ('b * 'c -> 'd) -> 'e -> 'f ->
2010  ''g * int -> string
2011  val test10a = "OK" : string
2012  val test10b = "OK" : string
2013  val test10c = "OK" : string
2014  val test10d = "OK" : string
2015  val test10e = "OK" : string
2016  val test10f = "OK" : string
2017  val test10g = "OK" : string
2018  val test11a = "OK" : string
2019  val test11b = "OK" : string
2020  val test11c = "OK" : string
2021  val test11d = "OK" : string
2022  val test11e = "OK" : string
2023  val test12a = "OK" : string
2024  val test12b = "OK" : string
2025  val test12c = "OK" : string
2026  val test12d = "OK" : string
2027  val test13 = "OK" : string
2028  val test14 = "OK" : string
2029  val test15 = "OK" : string
2030  val test16 = "OK" : string
2031[closing file "word8vector.sml"]
2032[opening file "word8vectorslice.sml"]
2033[opening file "auxil.sml"]
2034> infix 1 seq
2035  val ('b, 'c) seq = fn : 'b * 'c -> 'c
2036> val check = fn : bool -> string
2037> val check' = fn : (unit -> bool) -> string
2038> val range = fn : int * int -> (int -> bool) -> bool
2039> val checkrange = fn : int * int -> (int -> bool) -> string
2040[closing file "auxil.sml"]
2041> val it = () : unit
2042> val a = <vector> : vector/1
2043  val b = <vector> : vector/1
2044  val c = <vector> : vector/1
2045  val slice00 = <slice> : slice
2046  val slice01 = <slice> : slice
2047  val slice02 = <slice> : slice
2048  val slice03 = <slice> : slice
2049  val slice04 = <slice> : slice
2050  val slice05 = <slice> : slice
2051  val slicea07 = <slice> : slice
2052  val slicea02 = <slice> : slice
2053  val slicea23 = <slice> : slice
2054  val slicea25 = <slice> : slice
2055  val slice06 = <slice> : slice
2056  val slice07 = <slice> : slice
2057  val slice08 = <slice> : slice
2058  val slice09 = <slice> : slice
2059  val slice0s =
2060    [<slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>, <slice>,
2061     <slice>, <slice>] : slice list
2062  val sliceas = [<slice>, <slice>, <slice>, <slice>] : slice list
2063  val test1a = "OK" : string
2064  val test1b = "OK" : string
2065  val test2a = "OK" : string
2066  val test2b = "OK" : string
2067  val test2c = "OK" : string
2068  val test2d = "OK" : string
2069  val test2e = "OK" : string
2070  val test3a = "OK" : string
2071  val test4a = "OK" : string
2072  val test4b = "OK" : string
2073  val test4c = "OK" : string
2074  val test4d = "OK" : string
2075  val test4e = "OK" : string
2076  val test4f = "OK" : string
2077  val test4g = "OK" : string
2078  val test5 = "OK" : string
2079  val sliced = <slice> : slice
2080  val sliceb = <slice> : slice
2081  val e = <array> : array
2082  val ev = <vector> : vector/1
2083  val slicee = <slice> : slice
2084  val test9a = "OK" : string
2085  val test9b = "OK" : string
2086  val g = <array> : array
2087  val sliceg = <slice> : slice
2088  val test10a = "OK" : string
2089  val sliceg0 = <slice> : slice
2090  val test10b = "OK" : string
2091  val sliceg1 = <slice> : slice
2092  val test10c = "OK" : string
2093  val sliceg202 = <slice> : slice
2094  val test10d = "OK" : string
2095  val test11a = "OK" : string
2096  val test11b = "OK" : string
2097  val test11c = "OK" : string
2098  val test12a = "OK" : string
2099  val test12b = "OK" : string
2100  val test12c = "OK" : string
2101  val test12d = "OK" : string
2102  val test12f = "OK" : string
2103  val test12g = "OK" : string
2104  val test12h = "OK" : string
2105  val test12i = "OK" : string
2106  val test13 = "OK" : string
2107  val test14a = "OK" : string
2108  val test14b = "OK" : string
2109  val test15 = "OK" : string
2110  val test17a = "OK" : string
2111  val test17b = "OK" : string
2112[closing file "word8vectorslice.sml"]
2113> val it = () : unit
2114