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