Commits

camlspotter  committed 672f324

standalone build for test

  • Participants
  • Parent commits 9772345
  • Branches inline

Comments (0)

Files changed (36)

File spotlib/OMakefile

+

File spotlib/OMakefile.omc

Binary file added.

File spotlib/monad.annot

+"monad.ml" 6 84 90 "monad.ml" 6 84 93
+type(
+  f:('a -> 'b) -> 'a t -> 'b t
+)
+ident(
+  def map "monad.ml" 8 133 135 "monad.ml" 49 1010 1013
+)
+"monad.ml" 6 84 95 "monad.ml" 6 84 96
+type(
+  'a -> 'b
+)
+ident(
+  def f "monad.ml" 6 84 97 "monad.ml" 6 84 131
+)
+"monad.ml" 6 84 97 "monad.ml" 6 84 98
+type(
+  'a t
+)
+ident(
+  def t "monad.ml" 6 84 101 "monad.ml" 6 84 131
+)
+"monad.ml" 6 84 101 "monad.ml" 6 84 105
+type(
+  'a t -> ('a -> 'b t) -> 'b t
+)
+"monad.ml" 6 84 106 "monad.ml" 6 84 107
+type(
+  'a t
+)
+ident(
+  int_ref t "monad.ml" 6 84 97 "monad.ml" 6 84 98
+)
+"monad.ml" 6 84 113 "monad.ml" 6 84 114
+type(
+  'a
+)
+ident(
+  def x "monad.ml" 6 84 118 "monad.ml" 6 84 130
+)
+"monad.ml" 6 84 118 "monad.ml" 6 84 124
+type(
+  'b -> 'b t
+)
+"monad.ml" 6 84 126 "monad.ml" 6 84 127
+type(
+  'a -> 'b
+)
+ident(
+  int_ref f "monad.ml" 6 84 95 "monad.ml" 6 84 96
+)
+"monad.ml" 6 84 128 "monad.ml" 6 84 129
+type(
+  'a
+)
+ident(
+  int_ref x "monad.ml" 6 84 113 "monad.ml" 6 84 114
+)
+"monad.ml" 6 84 125 "monad.ml" 6 84 130
+call(
+  stack
+)
+type(
+  'b
+)
+"monad.ml" 6 84 118 "monad.ml" 6 84 130
+call(
+  tail
+)
+type(
+  'b t
+)
+"monad.ml" 6 84 108 "monad.ml" 6 84 131
+type(
+  'a -> 'b t
+)
+"monad.ml" 6 84 101 "monad.ml" 6 84 131
+call(
+  tail
+)
+type(
+  'b t
+)
+"monad.ml" 9 157 165 "monad.ml" 9 157 169
+type(
+  'c M.t -> ('c -> 'd M.t) -> 'd M.t
+)
+ident(
+  def bind "monad.ml" 10 179 183 "monad.ml" 20 440 445
+)
+"monad.ml" 9 157 172 "monad.ml" 9 157 178
+type(
+  'c M.t -> ('c -> 'd M.t) -> 'd M.t
+)
+ident(
+  ext_ref M.bind
+)
+"monad.ml" 10 179 187 "monad.ml" 10 179 192
+type(
+  'e M.t -> ('e -> 'f M.t) -> 'f M.t
+)
+ident(
+  def >>= "monad.ml" 11 202 206 "monad.ml" 20 440 445
+)
+"monad.ml" 10 179 195 "monad.ml" 10 179 201
+type(
+  'e M.t -> ('e -> 'f M.t) -> 'f M.t
+)
+ident(
+  ext_ref M.bind
+)
+"monad.ml" 11 202 210 "monad.ml" 11 202 215
+type(
+  'g t -> ('g -> 'h) -> 'h t
+)
+ident(
+  def >>| "monad.ml" 12 231 235 "monad.ml" 20 440 445
+)
+"monad.ml" 11 202 216 "monad.ml" 11 202 217
+type(
+  'g t
+)
+ident(
+  def t "monad.ml" 11 202 218 "monad.ml" 11 202 230
+)
+"monad.ml" 11 202 218 "monad.ml" 11 202 219
+type(
+  'g -> 'h
+)
+ident(
+  def f "monad.ml" 11 202 222 "monad.ml" 11 202 230
+)
+"monad.ml" 11 202 222 "monad.ml" 11 202 225
+type(
+  f:('g -> 'h) -> 'g t -> 'h t
+)
+ident(
+  int_ref map "monad.ml" 6 84 90 "monad.ml" 6 84 93
+)
+"monad.ml" 11 202 227 "monad.ml" 11 202 228
+type(
+  'g -> 'h
+)
+ident(
+  int_ref f "monad.ml" 11 202 218 "monad.ml" 11 202 219
+)
+"monad.ml" 11 202 229 "monad.ml" 11 202 230
+type(
+  'g t
+)
+ident(
+  int_ref t "monad.ml" 11 202 216 "monad.ml" 11 202 217
+)
+"monad.ml" 11 202 222 "monad.ml" 11 202 230
+call(
+  tail
+)
+type(
+  'h t
+)
+"monad.ml" 12 231 239 "monad.ml" 12 231 245
+type(
+  'i -> 'i t
+)
+ident(
+  def return "monad.ml" 15 284 288 "monad.ml" 20 440 445
+)
+"monad.ml" 12 231 248 "monad.ml" 12 231 254
+type(
+  'i -> 'i t
+)
+"monad.ml" 15 284 292 "monad.ml" 15 284 300
+type(
+  ('j -> 'k) -> 'j t -> 'k t
+)
+ident(
+  def ^<$> "monad.ml" 16 317 321 "monad.ml" 20 440 445
+)
+"monad.ml" 15 284 301 "monad.ml" 15 284 302
+type(
+  'j -> 'k
+)
+ident(
+  def f "monad.ml" 15 284 303 "monad.ml" 15 284 315
+)
+"monad.ml" 15 284 303 "monad.ml" 15 284 304
+type(
+  'j t
+)
+ident(
+  def t "monad.ml" 15 284 307 "monad.ml" 15 284 315
+)
+"monad.ml" 15 284 307 "monad.ml" 15 284 310
+type(
+  f:('j -> 'k) -> 'j t -> 'k t
+)
+ident(
+  int_ref map "monad.ml" 6 84 90 "monad.ml" 6 84 93
+)
+"monad.ml" 15 284 312 "monad.ml" 15 284 313
+type(
+  'j -> 'k
+)
+ident(
+  int_ref f "monad.ml" 15 284 301 "monad.ml" 15 284 302
+)
+"monad.ml" 15 284 314 "monad.ml" 15 284 315
+type(
+  'j t
+)
+ident(
+  int_ref t "monad.ml" 15 284 303 "monad.ml" 15 284 304
+)
+"monad.ml" 15 284 307 "monad.ml" 15 284 315
+call(
+  tail
+)
+type(
+  'k t
+)
+"monad.ml" 16 317 325 "monad.ml" 16 317 333
+type(
+  ('l -> 'm) t -> 'l t -> 'm t
+)
+ident(
+  def /<*> "monad.ml" 19 421 439 "monad.ml" 20 440 445
+)
+"monad.ml" 16 317 371 "monad.ml" 16 317 372
+type(
+  ('l -> 'm) t
+)
+ident(
+  def f "monad.ml" 16 317 373 "monad.ml" 19 421 439
+)
+"monad.ml" 16 317 373 "monad.ml" 16 317 374
+type(
+  'l t
+)
+ident(
+  def a "monad.ml" 17 378 384 "monad.ml" 19 421 439
+)
+"monad.ml" 17 378 384 "monad.ml" 17 378 385
+type(
+  ('l -> 'm) t
+)
+ident(
+  int_ref f "monad.ml" 16 317 371 "monad.ml" 16 317 372
+)
+"monad.ml" 17 378 386 "monad.ml" 17 378 389
+type(
+  ('l -> 'm) t -> (('l -> 'm) -> 'm M.t) -> 'm t
+)
+ident(
+  int_ref >>= "monad.ml" 10 179 187 "monad.ml" 10 179 192
+)
+"monad.ml" 17 378 394 "monad.ml" 17 378 395
+type(
+  'l -> 'm
+)
+ident(
+  def f "monad.ml" 18 400 406 "monad.ml" 19 421 439
+)
+"monad.ml" 18 400 406 "monad.ml" 18 400 407
+type(
+  'l t
+)
+ident(
+  int_ref a "monad.ml" 16 317 373 "monad.ml" 16 317 374
+)
+"monad.ml" 18 400 408 "monad.ml" 18 400 411
+type(
+  'l t -> ('l -> 'm t) -> 'm M.t
+)
+ident(
+  int_ref >>= "monad.ml" 10 179 187 "monad.ml" 10 179 192
+)
+"monad.ml" 18 400 416 "monad.ml" 18 400 417
+type(
+  'l
+)
+ident(
+  def a "monad.ml" 19 421 427 "monad.ml" 19 421 439
+)
+"monad.ml" 19 421 427 "monad.ml" 19 421 433
+type(
+  'm -> 'm t
+)
+ident(
+  int_ref return "monad.ml" 12 231 239 "monad.ml" 12 231 245
+)
+"monad.ml" 19 421 435 "monad.ml" 19 421 436
+type(
+  'l -> 'm
+)
+ident(
+  int_ref f "monad.ml" 17 378 394 "monad.ml" 17 378 395
+)
+"monad.ml" 19 421 437 "monad.ml" 19 421 438
+type(
+  'l
+)
+ident(
+  int_ref a "monad.ml" 18 400 416 "monad.ml" 18 400 417
+)
+"monad.ml" 19 421 434 "monad.ml" 19 421 439
+call(
+  stack
+)
+type(
+  'm
+)
+"monad.ml" 19 421 427 "monad.ml" 19 421 439
+call(
+  tail
+)
+type(
+  'm t
+)
+"monad.ml" 18 400 412 "monad.ml" 19 421 439
+type(
+  'l -> 'm t
+)
+"monad.ml" 18 400 406 "monad.ml" 19 421 439
+call(
+  tail
+)
+type(
+  'm M.t
+)
+"monad.ml" 17 378 390 "monad.ml" 19 421 439
+type(
+  ('l -> 'm) -> 'm M.t
+)
+"monad.ml" 17 378 384 "monad.ml" 19 421 439
+call(
+  tail
+)
+type(
+  'm t
+)
+"monad.ml" 16 317 367 "monad.ml" 19 421 439
+type(
+  ('l -> 'm) t -> 'l t -> 'm t
+)
+type(
+  ('l -> 'm) t -> 'l t -> 'm t
+)
+"monad.ml" 27 533 539 "monad.ml" 27 533 545
+type(
+  'n M.t -> unit M.t
+)
+ident(
+  def ignore "monad.ml" 28 575 577 "monad.ml" 49 1010 1013
+)
+"monad.ml" 27 533 546 "monad.ml" 27 533 547
+type(
+  'n M.t
+)
+ident(
+  def a "monad.ml" 27 533 550 "monad.ml" 27 533 574
+)
+"monad.ml" 27 533 550 "monad.ml" 27 533 551
+type(
+  'n M.t
+)
+ident(
+  int_ref a "monad.ml" 27 533 546 "monad.ml" 27 533 547
+)
+"monad.ml" 27 533 552 "monad.ml" 27 533 555
+type(
+  'n M.t -> ('n -> unit t) -> unit M.t
+)
+"monad.ml" 27 533 560 "monad.ml" 27 533 561
+type(
+  'n
+)
+"monad.ml" 27 533 565 "monad.ml" 27 533 571
+type(
+  unit -> unit t
+)
+"monad.ml" 27 533 572 "monad.ml" 27 533 574
+type(
+  unit
+)
+"monad.ml" 27 533 565 "monad.ml" 27 533 574
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 27 533 556 "monad.ml" 27 533 574
+type(
+  'n -> unit t
+)
+"monad.ml" 27 533 550 "monad.ml" 27 533 574
+call(
+  tail
+)
+type(
+  unit M.t
+)
+"monad.ml" 28 575 581 "monad.ml" 28 575 585
+type(
+  'o M.t -> unit M.t
+)
+ident(
+  def void "monad.ml" 30 596 598 "monad.ml" 49 1010 1013
+)
+"monad.ml" 28 575 588 "monad.ml" 28 575 594
+type(
+  'o M.t -> unit M.t
+)
+ident(
+  int_ref ignore "monad.ml" 27 533 539 "monad.ml" 27 533 545
+)
+"monad.ml" 30 596 606 "monad.ml" 30 596 609
+type(
+  'p M.t list -> 'p list t
+)
+ident(
+  def seq "monad.ml" 30 596 598 "monad.ml" 49 1010 1013
+)
+"monad.ml" 31 621 627 "monad.ml" 31 621 629
+type(
+  'p M.t list
+)
+"monad.ml" 31 621 633 "monad.ml" 31 621 639
+type(
+  'p list -> 'p list t
+)
+"monad.ml" 31 621 640 "monad.ml" 31 621 642
+type(
+  'p list
+)
+"monad.ml" 31 621 633 "monad.ml" 31 621 642
+call(
+  tail
+)
+type(
+  'p list t
+)
+"monad.ml" 32 643 649 "monad.ml" 32 643 650
+type(
+  'p M.t
+)
+ident(
+  def x "monad.ml" 33 659 667 "monad.ml" 35 712 734
+)
+"monad.ml" 32 643 652 "monad.ml" 32 643 654
+type(
+  'p M.t list
+)
+ident(
+  def xs "monad.ml" 33 659 667 "monad.ml" 35 712 734
+)
+"monad.ml" 32 643 649 "monad.ml" 32 643 654
+type(
+  'p M.t list
+)
+"monad.ml" 33 659 667 "monad.ml" 33 659 668
+type(
+  'p M.t
+)
+ident(
+  int_ref x "monad.ml" 32 643 649 "monad.ml" 32 643 650
+)
+"monad.ml" 33 659 669 "monad.ml" 33 659 672
+type(
+  'p M.t -> ('p -> 'p list M.t) -> 'p list t
+)
+"monad.ml" 33 659 677 "monad.ml" 33 659 678
+type(
+  'p
+)
+ident(
+  def x "monad.ml" 34 683 691 "monad.ml" 35 712 734
+)
+"monad.ml" 34 683 691 "monad.ml" 34 683 694
+type(
+  'p M.t list -> 'p list t
+)
+ident(
+  int_ref seq "monad.ml" 30 596 606 "monad.ml" 30 596 609
+)
+"monad.ml" 34 683 695 "monad.ml" 34 683 697
+type(
+  'p M.t list
+)
+ident(
+  int_ref xs "monad.ml" 32 643 652 "monad.ml" 32 643 654
+)
+"monad.ml" 34 683 691 "monad.ml" 34 683 697
+call(
+  stack
+)
+type(
+  'p list t
+)
+"monad.ml" 34 683 698 "monad.ml" 34 683 701
+type(
+  'p list t -> ('p list -> 'p list t) -> 'p list M.t
+)
+"monad.ml" 34 683 706 "monad.ml" 34 683 708
+type(
+  'p list
+)
+ident(
+  def xs "monad.ml" 35 712 720 "monad.ml" 35 712 734
+)
+"monad.ml" 35 712 720 "monad.ml" 35 712 726
+type(
+  'p list -> 'p list t
+)
+"monad.ml" 35 712 728 "monad.ml" 35 712 729
+type(
+  'p
+)
+ident(
+  int_ref x "monad.ml" 33 659 677 "monad.ml" 33 659 678
+)
+"monad.ml" 35 712 731 "monad.ml" 35 712 733
+type(
+  'p list
+)
+ident(
+  int_ref xs "monad.ml" 34 683 706 "monad.ml" 34 683 708
+)
+"monad.ml" 35 712 727 "monad.ml" 35 712 734
+type(
+  'p list
+)
+"monad.ml" 35 712 720 "monad.ml" 35 712 734
+call(
+  tail
+)
+type(
+  'p list t
+)
+"monad.ml" 34 683 702 "monad.ml" 35 712 734
+type(
+  'p list -> 'p list t
+)
+"monad.ml" 34 683 691 "monad.ml" 35 712 734
+call(
+  tail
+)
+type(
+  'p list M.t
+)
+"monad.ml" 33 659 673 "monad.ml" 35 712 734
+type(
+  'p -> 'p list M.t
+)
+"monad.ml" 33 659 667 "monad.ml" 35 712 734
+call(
+  tail
+)
+type(
+  'p list t
+)
+"monad.ml" 30 596 612 "monad.ml" 35 712 734
+type(
+  'p M.t list -> 'p list t
+)
+"monad.ml" 37 736 746 "monad.ml" 37 736 750
+type(
+  unit M.t list -> unit t
+)
+ident(
+  def seq_ "monad.ml" 37 736 738 "monad.ml" 49 1010 1013
+)
+"monad.ml" 38 762 768 "monad.ml" 38 762 770
+type(
+  unit M.t list
+)
+"monad.ml" 38 762 774 "monad.ml" 38 762 780
+type(
+  unit -> unit t
+)
+"monad.ml" 38 762 781 "monad.ml" 38 762 783
+type(
+  unit
+)
+"monad.ml" 38 762 774 "monad.ml" 38 762 783
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 39 784 790 "monad.ml" 39 784 791
+type(
+  unit M.t
+)
+ident(
+  def x "monad.ml" 39 784 799 "monad.ml" 39 784 822
+)
+"monad.ml" 39 784 793 "monad.ml" 39 784 795
+type(
+  unit M.t list
+)
+ident(
+  def xs "monad.ml" 39 784 799 "monad.ml" 39 784 822
+)
+"monad.ml" 39 784 790 "monad.ml" 39 784 795
+type(
+  unit M.t list
+)
+"monad.ml" 39 784 799 "monad.ml" 39 784 800
+type(
+  unit M.t
+)
+ident(
+  int_ref x "monad.ml" 39 784 790 "monad.ml" 39 784 791
+)
+"monad.ml" 39 784 801 "monad.ml" 39 784 804
+type(
+  unit M.t -> (unit -> unit t) -> unit t
+)
+"monad.ml" 39 784 809 "monad.ml" 39 784 811
+type(
+  unit
+)
+"monad.ml" 39 784 815 "monad.ml" 39 784 819
+type(
+  unit M.t list -> unit t
+)
+ident(
+  int_ref seq_ "monad.ml" 37 736 746 "monad.ml" 37 736 750
+)
+"monad.ml" 39 784 820 "monad.ml" 39 784 822
+type(
+  unit M.t list
+)
+ident(
+  int_ref xs "monad.ml" 39 784 793 "monad.ml" 39 784 795
+)
+"monad.ml" 39 784 815 "monad.ml" 39 784 822
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 39 784 805 "monad.ml" 39 784 822
+type(
+  unit -> unit t
+)
+"monad.ml" 39 784 799 "monad.ml" 39 784 822
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 37 736 753 "monad.ml" 39 784 822
+type(
+  unit M.t list -> unit t
+)
+"monad.ml" 41 824 830 "monad.ml" 41 824 834
+type(
+  ('q -> 'r M.t) -> 'q list -> 'r list t
+)
+ident(
+  def mapM "monad.ml" 43 863 865 "monad.ml" 49 1010 1013
+)
+"monad.ml" 41 824 835 "monad.ml" 41 824 836
+type(
+  'q -> 'r M.t
+)
+ident(
+  def f "monad.ml" 41 824 837 "monad.ml" 41 824 861
+)
+"monad.ml" 41 824 837 "monad.ml" 41 824 839
+type(
+  'q list
+)
+ident(
+  def ls "monad.ml" 41 824 842 "monad.ml" 41 824 861
+)
+"monad.ml" 41 824 842 "monad.ml" 41 824 845
+type(
+  'r M.t list -> 'r list t
+)
+ident(
+  int_ref seq "monad.ml" 30 596 606 "monad.ml" 30 596 609
+)
+"monad.ml" 41 824 847 "monad.ml" 41 824 855
+type(
+  ('q -> 'r M.t) -> 'q list -> 'r M.t list
+)
+ident(
+  ext_ref List.map
+)
+"monad.ml" 41 824 856 "monad.ml" 41 824 857
+type(
+  'q -> 'r M.t
+)
+ident(
+  int_ref f "monad.ml" 41 824 835 "monad.ml" 41 824 836
+)
+"monad.ml" 41 824 858 "monad.ml" 41 824 860
+type(
+  'q list
+)
+ident(
+  int_ref ls "monad.ml" 41 824 837 "monad.ml" 41 824 839
+)
+"monad.ml" 41 824 846 "monad.ml" 41 824 861
+call(
+  stack
+)
+type(
+  'r M.t list
+)
+"monad.ml" 41 824 842 "monad.ml" 41 824 861
+call(
+  tail
+)
+type(
+  'r list t
+)
+"monad.ml" 43 863 873 "monad.ml" 43 863 877
+type(
+  int -> int -> (int -> unit M.t) -> unit t
+)
+ident(
+  def for_ "monad.ml" 43 863 865 "monad.ml" 49 1010 1013
+)
+"monad.ml" 43 863 878 "monad.ml" 43 863 879
+type(
+  int
+)
+ident(
+  def i "monad.ml" 43 863 880 "monad.ml" 45 918 961
+)
+"monad.ml" 43 863 880 "monad.ml" 43 863 883
+type(
+  int
+)
+ident(
+  def to_ "monad.ml" 43 863 884 "monad.ml" 45 918 961
+)
+"monad.ml" 43 863 884 "monad.ml" 43 863 885
+type(
+  int -> unit M.t
+)
+ident(
+  def f "monad.ml" 44 888 892 "monad.ml" 45 918 961
+)
+"monad.ml" 44 888 895 "monad.ml" 44 888 896
+type(
+  int
+)
+ident(
+  int_ref i "monad.ml" 43 863 878 "monad.ml" 43 863 879
+)
+"monad.ml" 44 888 897 "monad.ml" 44 888 898
+type(
+  int -> int -> bool
+)
+ident(
+  ext_ref Pervasives.( > )
+)
+"monad.ml" 44 888 899 "monad.ml" 44 888 902
+type(
+  int
+)
+ident(
+  int_ref to_ "monad.ml" 43 863 880 "monad.ml" 43 863 883
+)
+"monad.ml" 44 888 895 "monad.ml" 44 888 902
+type(
+  bool
+)
+"monad.ml" 44 888 908 "monad.ml" 44 888 914
+type(
+  unit -> unit t
+)
+"monad.ml" 44 888 915 "monad.ml" 44 888 917
+type(
+  unit
+)
+"monad.ml" 44 888 908 "monad.ml" 44 888 917
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 45 918 927 "monad.ml" 45 918 928
+type(
+  int -> unit M.t
+)
+ident(
+  int_ref f "monad.ml" 43 863 884 "monad.ml" 43 863 885
+)
+"monad.ml" 45 918 929 "monad.ml" 45 918 930
+type(
+  int
+)
+ident(
+  int_ref i "monad.ml" 43 863 878 "monad.ml" 43 863 879
+)
+"monad.ml" 45 918 927 "monad.ml" 45 918 930
+call(
+  stack
+)
+type(
+  unit M.t
+)
+"monad.ml" 45 918 931 "monad.ml" 45 918 934
+type(
+  unit M.t -> (unit -> unit t) -> unit t
+)
+"monad.ml" 45 918 939 "monad.ml" 45 918 941
+type(
+  unit
+)
+"monad.ml" 45 918 945 "monad.ml" 45 918 949
+type(
+  int -> int -> (int -> unit M.t) -> unit t
+)
+ident(
+  int_ref for_ "monad.ml" 43 863 873 "monad.ml" 43 863 877
+)
+"monad.ml" 45 918 951 "monad.ml" 45 918 952
+type(
+  int
+)
+ident(
+  int_ref i "monad.ml" 43 863 878 "monad.ml" 43 863 879
+)
+"monad.ml" 45 918 952 "monad.ml" 45 918 953
+type(
+  int -> int -> int
+)
+ident(
+  ext_ref Pervasives.( + )
+)
+"monad.ml" 45 918 953 "monad.ml" 45 918 954
+type(
+  int
+)
+"monad.ml" 45 918 950 "monad.ml" 45 918 955
+type(
+  int
+)
+"monad.ml" 45 918 956 "monad.ml" 45 918 959
+type(
+  int
+)
+ident(
+  int_ref to_ "monad.ml" 43 863 880 "monad.ml" 43 863 883
+)
+"monad.ml" 45 918 960 "monad.ml" 45 918 961
+type(
+  int -> unit M.t
+)
+ident(
+  int_ref f "monad.ml" 43 863 884 "monad.ml" 43 863 885
+)
+"monad.ml" 45 918 945 "monad.ml" 45 918 961
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 45 918 935 "monad.ml" 45 918 961
+type(
+  unit -> unit t
+)
+"monad.ml" 45 918 927 "monad.ml" 45 918 961
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 44 888 892 "monad.ml" 45 918 961
+type(
+  unit t
+)
+"monad.ml" 47 967 973 "monad.ml" 47 967 978
+type(
+  (int -> 's -> unit M.t) -> 's list -> unit t
+)
+ident(
+  def iteri "monad.ml" 47 967 1008 "monad.ml" 49 1010 1013
+)
+"monad.ml" 47 967 979 "monad.ml" 47 967 980
+type(
+  int -> 's -> unit M.t
+)
+ident(
+  def f "monad.ml" 47 967 981 "monad.ml" 47 967 1008
+)
+"monad.ml" 47 967 981 "monad.ml" 47 967 983
+type(
+  's list
+)
+ident(
+  def ls "monad.ml" 47 967 986 "monad.ml" 47 967 1008
+)
+"monad.ml" 47 967 986 "monad.ml" 47 967 990
+type(
+  unit M.t list -> unit t
+)
+ident(
+  int_ref seq_ "monad.ml" 37 736 746 "monad.ml" 37 736 750
+)
+"monad.ml" 47 967 992 "monad.ml" 47 967 1002
+type(
+  (int -> 's -> unit M.t) -> 's list -> unit M.t list
+)
+ident(
+  ext_ref Xlist.mapi
+)
+"monad.ml" 47 967 1003 "monad.ml" 47 967 1004
+type(
+  int -> 's -> unit M.t
+)
+ident(
+  int_ref f "monad.ml" 47 967 979 "monad.ml" 47 967 980
+)
+"monad.ml" 47 967 1005 "monad.ml" 47 967 1007
+type(
+  's list
+)
+ident(
+  int_ref ls "monad.ml" 47 967 981 "monad.ml" 47 967 983
+)
+"monad.ml" 47 967 991 "monad.ml" 47 967 1008
+call(
+  stack
+)
+type(
+  unit M.t list
+)
+"monad.ml" 47 967 986 "monad.ml" 47 967 1008
+call(
+  tail
+)
+type(
+  unit t
+)
+"monad.ml" 54 1097 1103 "monad.ml" 54 1097 1106
+type(
+  f:('a -> 'b) -> ('a, 'c) t -> ('b, 'c) t
+)
+ident(
+  def map "monad.ml" 56 1146 1148 "monad.ml" 97 2016 2019
+)
+"monad.ml" 54 1097 1108 "monad.ml" 54 1097 1109
+type(
+  'a -> 'b
+)
+ident(
+  def f "monad.ml" 54 1097 1110 "monad.ml" 54 1097 1144
+)
+"monad.ml" 54 1097 1110 "monad.ml" 54 1097 1111
+type(
+  ('a, 'c) t
+)
+ident(
+  def t "monad.ml" 54 1097 1114 "monad.ml" 54 1097 1144
+)
+"monad.ml" 54 1097 1114 "monad.ml" 54 1097 1118
+type(
+  ('a, 'c) t -> ('a -> ('b, 'c) t) -> ('b, 'c) t
+)
+"monad.ml" 54 1097 1119 "monad.ml" 54 1097 1120
+type(
+  ('a, 'c) t
+)
+ident(
+  int_ref t "monad.ml" 54 1097 1110 "monad.ml" 54 1097 1111
+)
+"monad.ml" 54 1097 1126 "monad.ml" 54 1097 1127
+type(
+  'a
+)
+ident(
+  def x "monad.ml" 54 1097 1131 "monad.ml" 54 1097 1143
+)
+"monad.ml" 54 1097 1131 "monad.ml" 54 1097 1137
+type(
+  'b -> ('b, 'c) t
+)
+"monad.ml" 54 1097 1139 "monad.ml" 54 1097 1140
+type(
+  'a -> 'b
+)
+ident(
+  int_ref f "monad.ml" 54 1097 1108 "monad.ml" 54 1097 1109
+)
+"monad.ml" 54 1097 1141 "monad.ml" 54 1097 1142
+type(
+  'a
+)
+ident(
+  int_ref x "monad.ml" 54 1097 1126 "monad.ml" 54 1097 1127
+)
+"monad.ml" 54 1097 1138 "monad.ml" 54 1097 1143
+call(
+  stack
+)
+type(
+  'b
+)
+"monad.ml" 54 1097 1131 "monad.ml" 54 1097 1143
+call(
+  tail
+)
+type(
+  ('b, 'c) t
+)
+"monad.ml" 54 1097 1121 "monad.ml" 54 1097 1144
+type(
+  'a -> ('b, 'c) t
+)
+"monad.ml" 54 1097 1114 "monad.ml" 54 1097 1144
+call(
+  tail
+)
+type(
+  ('b, 'c) t
+)
+"monad.ml" 57 1170 1178 "monad.ml" 57 1170 1182
+type(
+  ('d, 'e) M.t -> ('d -> ('f, 'e) M.t) -> ('f, 'e) M.t
+)
+ident(
+  def bind "monad.ml" 58 1192 1196 "monad.ml" 68 1422 1427
+)
+"monad.ml" 57 1170 1185 "monad.ml" 57 1170 1191
+type(
+  ('d, 'e) M.t -> ('d -> ('f, 'e) M.t) -> ('f, 'e) M.t
+)
+ident(
+  ext_ref M.bind
+)
+"monad.ml" 58 1192 1200 "monad.ml" 58 1192 1205
+type(
+  ('g, 'h) M.t -> ('g -> ('i, 'h) M.t) -> ('i, 'h) M.t
+)
+ident(
+  def >>= "monad.ml" 59 1215 1219 "monad.ml" 68 1422 1427
+)
+"monad.ml" 58 1192 1208 "monad.ml" 58 1192 1214
+type(
+  ('g, 'h) M.t -> ('g -> ('i, 'h) M.t) -> ('i, 'h) M.t
+)
+ident(
+  ext_ref M.bind
+)
+"monad.ml" 59 1215 1223 "monad.ml" 59 1215 1228
+type(
+  ('j, 'k) t -> ('j -> 'l) -> ('l, 'k) t
+)
+ident(
+  def >>| "monad.ml" 60 1244 1248 "monad.ml" 68 1422 1427
+)
+"monad.ml" 59 1215 1229 "monad.ml" 59 1215 1230
+type(
+  ('j, 'k) t
+)
+ident(
+  def t "monad.ml" 59 1215 1231 "monad.ml" 59 1215 1243
+)
+"monad.ml" 59 1215 1231 "monad.ml" 59 1215 1232
+type(
+  'j -> 'l
+)
+ident(
+  def f "monad.ml" 59 1215 1235 "monad.ml" 59 1215 1243
+)
+"monad.ml" 59 1215 1235 "monad.ml" 59 1215 1238
+type(
+  f:('j -> 'l) -> ('j, 'k) t -> ('l, 'k) t
+)
+ident(
+  int_ref map "monad.ml" 54 1097 1103 "monad.ml" 54 1097 1106
+)
+"monad.ml" 59 1215 1240 "monad.ml" 59 1215 1241
+type(
+  'j -> 'l
+)
+ident(
+  int_ref f "monad.ml" 59 1215 1231 "monad.ml" 59 1215 1232
+)
+"monad.ml" 59 1215 1242 "monad.ml" 59 1215 1243
+type(
+  ('j, 'k) t
+)
+ident(
+  int_ref t "monad.ml" 59 1215 1229 "monad.ml" 59 1215 1230
+)
+"monad.ml" 59 1215 1235 "monad.ml" 59 1215 1243
+call(
+  tail
+)
+type(
+  ('l, 'k) t
+)
+"monad.ml" 60 1244 1252 "monad.ml" 60 1244 1258
+type(
+  'm -> ('m, 'n) t
+)
+ident(
+  def return "monad.ml" 63 1297 1301 "monad.ml" 68 1422 1427
+)
+"monad.ml" 60 1244 1261 "monad.ml" 60 1244 1267
+type(
+  'm -> ('m, 'n) t
+)
+"monad.ml" 63 1297 1305 "monad.ml" 63 1297 1313
+type(
+  ('o -> 'p) -> ('o, 'q) t -> ('p, 'q) t
+)
+ident(
+  def ^<$> "monad.ml" 64 1330 1334 "monad.ml" 68 1422 1427
+)
+"monad.ml" 63 1297 1314 "monad.ml" 63 1297 1315
+type(
+  'o -> 'p
+)
+ident(
+  def f "monad.ml" 63 1297 1316 "monad.ml" 63 1297 1328
+)
+"monad.ml" 63 1297 1316 "monad.ml" 63 1297 1317
+type(
+  ('o, 'q) t
+)
+ident(
+  def t "monad.ml" 63 1297 1320 "monad.ml" 63 1297 1328
+)
+"monad.ml" 63 1297 1320 "monad.ml" 63 1297 1323
+type(
+  f:('o -> 'p) -> ('o, 'q) t -> ('p, 'q) t
+)
+ident(
+  int_ref map "monad.ml" 54 1097 1103 "monad.ml" 54 1097 1106
+)
+"monad.ml" 63 1297 1325 "monad.ml" 63 1297 1326
+type(
+  'o -> 'p
+)
+ident(
+  int_ref f "monad.ml" 63 1297 1314 "monad.ml" 63 1297 1315
+)
+"monad.ml" 63 1297 1327 "monad.ml" 63 1297 1328
+type(
+  ('o, 'q) t
+)
+ident(
+  int_ref t "monad.ml" 63 1297 1316 "monad.ml" 63 1297 1317
+)
+"monad.ml" 63 1297 1320 "monad.ml" 63 1297 1328
+call(
+  tail
+)
+type(
+  ('p, 'q) t
+)
+"monad.ml" 64 1330 1338 "monad.ml" 64 1330 1346
+type(
+  ('r -> 's, 't) M.t -> ('r, 't) M.t -> ('s, 't) M.t
+)
+ident(
+  def /<*> "monad.ml" 67 1403 1421 "monad.ml" 68 1422 1427
+)
+"monad.ml" 64 1330 1353 "monad.ml" 64 1330 1354
+type(
+  ('r -> 's, 't) M.t
+)
+ident(
+  def f "monad.ml" 64 1330 1355 "monad.ml" 67 1403 1421
+)
+"monad.ml" 64 1330 1355 "monad.ml" 64 1330 1356
+type(
+  ('r, 't) M.t
+)
+ident(
+  def a "monad.ml" 65 1360 1366 "monad.ml" 67 1403 1421
+)
+"monad.ml" 65 1360 1366 "monad.ml" 65 1360 1367
+type(
+  ('r -> 's, 't) M.t
+)
+ident(
+  int_ref f "monad.ml" 64 1330 1353 "monad.ml" 64 1330 1354
+)
+"monad.ml" 65 1360 1368 "monad.ml" 65 1360 1371
+type(
+  ('r -> 's, 't) M.t -> (('r -> 's) -> ('s, 't) M.t) -> ('s, 't) M.t
+)
+ident(
+  int_ref >>= "monad.ml" 58 1192 1200 "monad.ml" 58 1192 1205
+)
+"monad.ml" 65 1360 1376 "monad.ml" 65 1360 1377
+type(
+  'r -> 's
+)
+ident(
+  def f "monad.ml" 66 1382 1388 "monad.ml" 67 1403 1421
+)
+"monad.ml" 66 1382 1388 "monad.ml" 66 1382 1389
+type(
+  ('r, 't) M.t
+)
+ident(
+  int_ref a "monad.ml" 64 1330 1355 "monad.ml" 64 1330 1356
+)
+"monad.ml" 66 1382 1390 "monad.ml" 66 1382 1393
+type(
+  ('r, 't) M.t -> ('r -> ('s, 't) t) -> ('s, 't) M.t
+)
+ident(
+  int_ref >>= "monad.ml" 58 1192 1200 "monad.ml" 58 1192 1205
+)
+"monad.ml" 66 1382 1398 "monad.ml" 66 1382 1399
+type(
+  'r
+)
+ident(
+  def a "monad.ml" 67 1403 1409 "monad.ml" 67 1403 1421
+)
+"monad.ml" 67 1403 1409 "monad.ml" 67 1403 1415
+type(
+  's -> ('s, 't) t
+)
+ident(
+  int_ref return "monad.ml" 60 1244 1252 "monad.ml" 60 1244 1258
+)
+"monad.ml" 67 1403 1417 "monad.ml" 67 1403 1418
+type(
+  'r -> 's
+)
+ident(
+  int_ref f "monad.ml" 65 1360 1376 "monad.ml" 65 1360 1377
+)
+"monad.ml" 67 1403 1419 "monad.ml" 67 1403 1420
+type(
+  'r
+)
+ident(
+  int_ref a "monad.ml" 66 1382 1398 "monad.ml" 66 1382 1399
+)
+"monad.ml" 67 1403 1416 "monad.ml" 67 1403 1421
+call(
+  stack
+)
+type(
+  's
+)
+"monad.ml" 67 1403 1409 "monad.ml" 67 1403 1421
+call(
+  tail
+)
+type(
+  ('s, 't) t
+)
+"monad.ml" 66 1382 1394 "monad.ml" 67 1403 1421
+type(
+  'r -> ('s, 't) t
+)
+"monad.ml" 66 1382 1388 "monad.ml" 67 1403 1421
+call(
+  tail
+)
+type(
+  ('s, 't) M.t
+)
+"monad.ml" 65 1360 1372 "monad.ml" 67 1403 1421
+type(
+  ('r -> 's) -> ('s, 't) M.t
+)
+"monad.ml" 65 1360 1366 "monad.ml" 67 1403 1421
+call(
+  tail
+)
+type(
+  ('s, 't) M.t
+)
+"monad.ml" 64 1330 1349 "monad.ml" 67 1403 1421
+type(
+  ('r -> 's, 't) M.t -> ('r, 't) M.t -> ('s, 't) M.t
+)
+"monad.ml" 75 1527 1533 "monad.ml" 75 1527 1539
+type(
+  ('u, 'v) M.t -> (unit, 'v) M.t
+)
+ident(
+  def ignore "monad.ml" 76 1569 1571 "monad.ml" 97 2016 2019
+)
+"monad.ml" 75 1527 1540 "monad.ml" 75 1527 1541
+type(
+  ('u, 'v) M.t
+)
+ident(
+  def a "monad.ml" 75 1527 1544 "monad.ml" 75 1527 1568
+)
+"monad.ml" 75 1527 1544 "monad.ml" 75 1527 1545
+type(
+  ('u, 'v) M.t
+)
+ident(
+  int_ref a "monad.ml" 75 1527 1540 "monad.ml" 75 1527 1541
+)
+"monad.ml" 75 1527 1546 "monad.ml" 75 1527 1549
+type(
+  ('u, 'v) M.t -> ('u -> (unit, 'v) t) -> (unit, 'v) M.t
+)
+"monad.ml" 75 1527 1554 "monad.ml" 75 1527 1555
+type(
+  'u
+)
+"monad.ml" 75 1527 1559 "monad.ml" 75 1527 1565
+type(
+  unit -> (unit, 'v) t
+)
+"monad.ml" 75 1527 1566 "monad.ml" 75 1527 1568
+type(
+  unit
+)
+"monad.ml" 75 1527 1559 "monad.ml" 75 1527 1568
+call(
+  tail
+)
+type(
+  (unit, 'v) t
+)
+"monad.ml" 75 1527 1550 "monad.ml" 75 1527 1568
+type(
+  'u -> (unit, 'v) t
+)
+"monad.ml" 75 1527 1544 "monad.ml" 75 1527 1568
+call(
+  tail
+)
+type(
+  (unit, 'v) M.t
+)
+"monad.ml" 76 1569 1575 "monad.ml" 76 1569 1579
+type(
+  ('w, 'x) M.t -> (unit, 'x) M.t
+)
+ident(
+  def void "monad.ml" 78 1590 1592 "monad.ml" 97 2016 2019
+)
+"monad.ml" 76 1569 1582 "monad.ml" 76 1569 1588
+type(
+  ('w, 'x) M.t -> (unit, 'x) M.t
+)
+ident(
+  int_ref ignore "monad.ml" 75 1527 1533 "monad.ml" 75 1527 1539
+)
+"monad.ml" 78 1590 1600 "monad.ml" 78 1590 1603
+type(
+  ('y, 'z) M.t list -> ('y list, 'z) t
+)
+ident(
+  def seq "monad.ml" 78 1590 1592 "monad.ml" 97 2016 2019
+)
+"monad.ml" 79 1615 1621 "monad.ml" 79 1615 1623
+type(
+  ('y, 'z) M.t list
+)
+"monad.ml" 79 1615 1627 "monad.ml" 79 1615 1633
+type(
+  'y list -> ('y list, 'z) t
+)
+"monad.ml" 79 1615 1634 "monad.ml" 79 1615 1636
+type(
+  'y list
+)
+"monad.ml" 79 1615 1627 "monad.ml" 79 1615 1636
+call(
+  tail
+)
+type(
+  ('y list, 'z) t
+)
+"monad.ml" 80 1637 1643 "monad.ml" 80 1637 1644
+type(
+  ('y, 'z) M.t
+)
+ident(
+  def x "monad.ml" 81 1653 1661 "monad.ml" 83 1706 1728
+)
+"monad.ml" 80 1637 1646 "monad.ml" 80 1637 1648
+type(
+  ('y, 'z) M.t list
+)
+ident(
+  def xs "monad.ml" 81 1653 1661 "monad.ml" 83 1706 1728
+)
+"monad.ml" 80 1637 1643 "monad.ml" 80 1637 1648
+type(
+  ('y, 'z) M.t list
+)
+"monad.ml" 81 1653 1661 "monad.ml" 81 1653 1662
+type(
+  ('y, 'z) M.t
+)
+ident(
+  int_ref x "monad.ml" 80 1637 1643 "monad.ml" 80 1637 1644
+)
+"monad.ml" 81 1653 1663 "monad.ml" 81 1653 1666
+type(
+  ('y, 'z) M.t -> ('y -> ('y list, 'z) M.t) -> ('y list, 'z) t
+)
+"monad.ml" 81 1653 1671 "monad.ml" 81 1653 1672
+type(
+  'y
+)
+ident(
+  def x "monad.ml" 82 1677 1685 "monad.ml" 83 1706 1728
+)
+"monad.ml" 82 1677 1685 "monad.ml" 82 1677 1688
+type(
+  ('y, 'z) M.t list -> ('y list, 'z) t
+)
+ident(
+  int_ref seq "monad.ml" 78 1590 1600 "monad.ml" 78 1590 1603
+)
+"monad.ml" 82 1677 1689 "monad.ml" 82 1677 1691
+type(
+  ('y, 'z) M.t list
+)
+ident(
+  int_ref xs "monad.ml" 80 1637 1646 "monad.ml" 80 1637 1648
+)
+"monad.ml" 82 1677 1685 "monad.ml" 82 1677 1691
+call(
+  stack
+)
+type(
+  ('y list, 'z) t
+)
+"monad.ml" 82 1677 1692 "monad.ml" 82 1677 1695
+type(
+  ('y list, 'z) t -> ('y list -> ('y list, 'z) t) -> ('y list, 'z) M.t
+)
+"monad.ml" 82 1677 1700 "monad.ml" 82 1677 1702
+type(
+  'y list
+)
+ident(
+  def xs "monad.ml" 83 1706 1714 "monad.ml" 83 1706 1728
+)
+"monad.ml" 83 1706 1714 "monad.ml" 83 1706 1720
+type(
+  'y list -> ('y list, 'z) t
+)
+"monad.ml" 83 1706 1722 "monad.ml" 83 1706 1723
+type(
+  'y
+)
+ident(
+  int_ref x "monad.ml" 81 1653 1671 "monad.ml" 81 1653 1672
+)
+"monad.ml" 83 1706 1725 "monad.ml" 83 1706 1727
+type(
+  'y list
+)
+ident(
+  int_ref xs "monad.ml" 82 1677 1700 "monad.ml" 82 1677 1702
+)
+"monad.ml" 83 1706 1721 "monad.ml" 83 1706 1728
+type(
+  'y list
+)
+"monad.ml" 83 1706 1714 "monad.ml" 83 1706 1728
+call(
+  tail
+)
+type(
+  ('y list, 'z) t
+)
+"monad.ml" 82 1677 1696 "monad.ml" 83 1706 1728
+type(
+  'y list -> ('y list, 'z) t
+)
+"monad.ml" 82 1677 1685 "monad.ml" 83 1706 1728
+call(
+  tail
+)
+type(
+  ('y list, 'z) M.t
+)
+"monad.ml" 81 1653 1667 "monad.ml" 83 1706 1728
+type(
+  'y -> ('y list, 'z) M.t
+)
+"monad.ml" 81 1653 1661 "monad.ml" 83 1706 1728
+call(
+  tail
+)
+type(
+  ('y list, 'z) t
+)
+"monad.ml" 78 1590 1606 "monad.ml" 83 1706 1728
+type(
+  ('y, 'z) M.t list -> ('y list, 'z) t
+)
+"monad.ml" 85 1730 1740 "monad.ml" 85 1730 1748
+type(
+  (unit, 'a1) M.t list -> (unit, 'a1) t
+)
+ident(
+  def seq_unit "monad.ml" 85 1730 1732 "monad.ml" 97 2016 2019
+)
+"monad.ml" 86 1760 1766 "monad.ml" 86 1760 1768
+type(
+  (unit, 'a1) M.t list
+)
+"monad.ml" 86 1760 1772 "monad.ml" 86 1760 1778
+type(
+  unit -> (unit, 'a1) t
+)
+"monad.ml" 86 1760 1779 "monad.ml" 86 1760 1781
+type(
+  unit
+)
+"monad.ml" 86 1760 1772 "monad.ml" 86 1760 1781
+call(
+  tail
+)
+type(
+  (unit, 'a1) t
+)
+"monad.ml" 87 1782 1788 "monad.ml" 87 1782 1789
+type(
+  (unit, 'a1) M.t
+)
+ident(
+  def x "monad.ml" 87 1782 1797 "monad.ml" 87 1782 1824
+)
+"monad.ml" 87 1782 1791 "monad.ml" 87 1782 1793
+type(
+  (unit, 'a1) M.t list
+)
+ident(
+  def xs "monad.ml" 87 1782 1797 "monad.ml" 87 1782 1824
+)
+"monad.ml" 87 1782 1788 "monad.ml" 87 1782 1793
+type(
+  (unit, 'a1) M.t list
+)
+"monad.ml" 87 1782 1797 "monad.ml" 87 1782 1798
+type(
+  (unit, 'a1) M.t
+)
+ident(
+  int_ref x "monad.ml" 87 1782 1788 "monad.ml" 87 1782 1789
+)
+"monad.ml" 87 1782 1799 "monad.ml" 87 1782 1802
+type(
+  (unit, 'a1) M.t -> (unit -> (unit, 'a1) t) -> (unit, 'a1) t
+)
+"monad.ml" 87 1782 1807 "monad.ml" 87 1782 1809
+type(
+  unit
+)
+"monad.ml" 87 1782 1813 "monad.ml" 87 1782 1821
+type(
+  (unit, 'a1) M.t list -> (unit, 'a1) t
+)
+ident(
+  int_ref seq_unit "monad.ml" 85 1730 1740 "monad.ml" 85 1730 1748
+)
+"monad.ml" 87 1782 1822 "monad.ml" 87 1782 1824
+type(
+  (unit, 'a1) M.t list
+)
+ident(
+  int_ref xs "monad.ml" 87 1782 1791 "monad.ml" 87 1782 1793
+)
+"monad.ml" 87 1782 1813 "monad.ml" 87 1782 1824
+call(
+  tail
+)
+type(
+  (unit, 'a1) t
+)
+"monad.ml" 87 1782 1803 "monad.ml" 87 1782 1824
+type(
+  unit -> (unit, 'a1) t
+)
+"monad.ml" 87 1782 1797 "monad.ml" 87 1782 1824
+call(
+  tail
+)
+type(
+  (unit, 'a1) t
+)
+"monad.ml" 85 1730 1751 "monad.ml" 87 1782 1824
+type(
+  (unit, 'a1) M.t list -> (unit, 'a1) t
+)
+"monad.ml" 89 1826 1832 "monad.ml" 89 1826 1836
+type(
+  ('b1 -> ('c1, 'd1) M.t) -> 'b1 list -> ('c1 list, 'd1) t
+)
+ident(
+  def mapM "monad.ml" 91 1865 1867 "monad.ml" 97 2016 2019
+)
+"monad.ml" 89 1826 1837 "monad.ml" 89 1826 1838
+type(
+  'b1 -> ('c1, 'd1) M.t
+)
+ident(
+  def f "monad.ml" 89 1826 1839 "monad.ml" 89 1826 1863
+)
+"monad.ml" 89 1826 1839 "monad.ml" 89 1826 1841
+type(
+  'b1 list
+)
+ident(
+  def ls "monad.ml" 89 1826 1844 "monad.ml" 89 1826 1863
+)
+"monad.ml" 89 1826 1844 "monad.ml" 89 1826 1847
+type(
+  ('c1, 'd1) M.t list -> ('c1 list, 'd1) t
+)
+ident(
+  int_ref seq "monad.ml" 78 1590 1600 "monad.ml" 78 1590 1603
+)
+"monad.ml" 89 1826 1849 "monad.ml" 89 1826 1857
+type(
+  ('b1 -> ('c1, 'd1) M.t) -> 'b1 list -> ('c1, 'd1) M.t list
+)
+ident(
+  ext_ref List.map
+)
+"monad.ml" 89 1826 1858 "monad.ml" 89 1826 1859
+type(
+  'b1 -> ('c1, 'd1) M.t
+)
+ident(
+  int_ref f "monad.ml" 89 1826 1837 "monad.ml" 89 1826 1838
+)
+"monad.ml" 89 1826 1860 "monad.ml" 89 1826 1862
+type(
+  'b1 list
+)
+ident(
+  int_ref ls "monad.ml" 89 1826 1839 "monad.ml" 89 1826 1841
+)
+"monad.ml" 89 1826 1848 "monad.ml" 89 1826 1863
+call(
+  stack
+)
+type(
+  ('c1, 'd1) M.t list
+)
+"monad.ml" 89 1826 1844 "monad.ml" 89 1826 1863
+call(
+  tail
+)
+type(
+  ('c1 list, 'd1) t
+)
+"monad.ml" 91 1865 1875 "monad.ml" 91 1865 1879
+type(
+  int -> int -> (int -> (unit, 'e1) M.t) -> (unit, 'e1) t
+)
+ident(
+  def for_ "monad.ml" 91 1865 1867 "monad.ml" 97 2016 2019
+)
+"monad.ml" 91 1865 1880 "monad.ml" 91 1865 1881
+type(
+  int
+)
+ident(
+  def i "monad.ml" 91 1865 1882 "monad.ml" 93 1920 1963
+)
+"monad.ml" 91 1865 1882 "monad.ml" 91 1865 1885
+type(
+  int
+)
+ident(
+  def to_ "monad.ml" 91 1865 1886 "monad.ml" 93 1920 1963
+)
+"monad.ml" 91 1865 1886 "monad.ml" 91 1865 1887
+type(
+  int -> (unit, 'e1) M.t
+)
+ident(
+  def f "monad.ml" 92 1890 1894 "monad.ml" 93 1920 1963
+)
+"monad.ml" 92 1890 1897 "monad.ml" 92 1890 1898
+type(
+  int
+)
+ident(
+  int_ref i "monad.ml" 91 1865 1880 "monad.ml" 91 1865 1881
+)
+"monad.ml" 92 1890 1899 "monad.ml" 92 1890 1900
+type(
+  int -> int -> bool
+)
+ident(
+  ext_ref Pervasives.( > )
+)
+"monad.ml" 92 1890 1901 "monad.ml" 92 1890 1904
+type(
+  int
+)
+ident(
+  int_ref to_ "monad.ml" 91 1865 1882 "monad.ml" 91 1865 1885
+)
+"monad.ml" 92 1890 1897 "monad.ml" 92 1890 1904
+type(
+  bool
+)
+"monad.ml" 92 1890 1910 "monad.ml" 92 1890 1916
+type(
+  unit -> (unit, 'e1) t
+)
+"monad.ml" 92 1890 1917 "monad.ml" 92 1890 1919
+type(
+  unit
+)
+"monad.ml" 92 1890 1910 "monad.ml" 92 1890 1919
+call(
+  tail
+)
+type(
+  (unit, 'e1) t
+)
+"monad.ml" 93 1920 1929 "monad.ml" 93 1920 1930
+type(
+  int -> (unit, 'e1) M.t
+)
+ident(
+  int_ref f "monad.ml" 91 1865 1886 "monad.ml" 91 1865 1887
+)
+"monad.ml" 93 1920 1931 "monad.ml" 93 1920 1932
+type(
+  int
+)
+ident(
+  int_ref i "monad.ml" 91 1865 1880 "monad.ml" 91 1865 1881
+)
+"monad.ml" 93 1920 1929 "monad.ml" 93 1920 1932
+call(
+  stack
+)
+type(
+  (unit, 'e1) M.t
+)
+"monad.ml" 93 1920 1933 "monad.ml" 93 1920 1936
+type(
+  (unit, 'e1) M.t -> (unit -> (unit, 'e1) t) -> (unit, 'e1) t
+)
+"monad.ml" 93 1920 1941 "monad.ml" 93 1920 1943
+type(
+  unit
+)
+"monad.ml" 93 1920 1947 "monad.ml" 93 1920 1951
+type(
+  int -> int -> (int -> (unit, 'e1) M.t) -> (unit, 'e1) t
+)
+ident(
+  int_ref for_ "monad.ml" 91 1865 1875 "monad.ml" 91 1865 1879
+)
+"monad.ml" 93 1920 1953 "monad.ml" 93 1920 1954
+type(
+  int
+)
+ident(
+  int_ref i "monad.ml" 91 1865 1880 "monad.ml" 91 1865 1881
+)
+"monad.ml" 93 1920 1954 "monad.ml" 93 1920 1955
+type(
+  int -> int -> int
+)
+ident(
+  ext_ref Pervasives.( + )
+)
+"monad.ml" 93 1920 1955 "monad.ml" 93 1920 1956
+type(
+  int
+)
+"monad.ml" 93 1920 1952 "monad.ml" 93 1920 1957
+type(
+  int
+)
+"monad.ml" 93 1920 1958 "monad.ml" 93 1920 1961
+type(
+  int
+)
+ident(
+  int_ref to_ "monad.ml" 91 1865 1882 "monad.ml" 91 1865 1885
+)
+"monad.ml" 93 1920 1962 "monad.ml" 93 1920 1963
+type(
+  int -> (unit, 'e1) M.t
+)
+ident(
+  int_ref f "monad.ml" 91 1865 1886 "monad.ml" 91 1865 1887
+)
+"monad.ml" 93 1920 1947 "monad.ml" 93 1920 1963
+call(
+  tail
+)
+type(
+  (unit, 'e1) t
+)
+"monad.ml" 93 1920 1937 "monad.ml" 93 1920 1963
+type(
+  unit -> (unit, 'e1) t
+)
+"monad.ml" 93 1920 1929 "monad.ml" 93 1920 1963
+call(
+  tail
+)
+type(
+  (unit, 'e1) t
+)
+"monad.ml" 92 1890 1894 "monad.ml" 93 1920 1963
+type(
+  (unit, 'e1) t
+)
+"monad.ml" 95 1969 1975 "monad.ml" 95 1969 1980
+type(
+  (int -> 'f1 -> (unit, 'g1) M.t) -> 'f1 list -> (unit, 'g1) t
+)
+ident(
+  def iteri "monad.ml" 95 1969 2014 "monad.ml" 97 2016 2019
+)
+"monad.ml" 95 1969 1981 "monad.ml" 95 1969 1982
+type(
+  int -> 'f1 -> (unit, 'g1) M.t
+)
+ident(
+  def f "monad.ml" 95 1969 1983 "monad.ml" 95 1969 2014
+)
+"monad.ml" 95 1969 1983 "monad.ml" 95 1969 1985
+type(
+  'f1 list
+)
+ident(
+  def ls "monad.ml" 95 1969 1988 "monad.ml" 95 1969 2014
+)
+"monad.ml" 95 1969 1988 "monad.ml" 95 1969 1996
+type(
+  (unit, 'g1) M.t list -> (unit, 'g1) t
+)
+ident(
+  int_ref seq_unit "monad.ml" 85 1730 1740 "monad.ml" 85 1730 1748
+)
+"monad.ml" 95 1969 1998 "monad.ml" 95 1969 2008
+type(
+  (int -> 'f1 -> (unit, 'g1) M.t) -> 'f1 list -> (unit, 'g1) M.t list
+)
+ident(
+  ext_ref Xlist.mapi
+)
+"monad.ml" 95 1969 2009 "monad.ml" 95 1969 2010
+type(
+  int -> 'f1 -> (unit, 'g1) M.t
+)
+ident(
+  int_ref f "monad.ml" 95 1969 1981 "monad.ml" 95 1969 1982
+)
+"monad.ml" 95 1969 2011 "monad.ml" 95 1969 2013
+type(
+  'f1 list
+)
+ident(
+  int_ref ls "monad.ml" 95 1969 1983 "monad.ml" 95 1969 1985
+)
+"monad.ml" 95 1969 1997 "monad.ml" 95 1969 2014
+call(
+  stack
+)
+type(
+  (unit, 'g1) M.t list
+)
+"monad.ml" 95 1969 1988 "monad.ml" 95 1969 2014
+call(
+  tail
+)
+type(
+  (unit, 'g1) t
+)

File spotlib/monad.cmi

Binary file added.

File spotlib/monad.cmo

Binary file added.

File spotlib/monad.cmx

Binary file added.

File spotlib/monad.ml

+open Monad_intf
+
+module Make(M:S) : T with type 'a t = 'a M.t = struct
+  include M
+
+  let map ~f t = bind t (fun x -> return (f x))
+
+  module Open_ = struct
+    let bind = M.bind
+    let (>>=) = M.bind
+    let (>>|) t f = map ~f t
+    let return = return
+
+    (* Applicative style *)
+    let ( ^<$> ) f t = map ~f t 
+    let ( /<*> ) : ('a -> 'b) t -> 'a t -> 'b t = fun f a ->
+      f >>= fun f -> 
+      a >>= fun a ->
+      return (f a)
+  end
+  include Open_
+  module Open = struct
+    type 'a t = 'a M.t
+    include Open_
+  end
+
+  let ignore a = a >>= fun _ -> return ()
+  let void = ignore
+
+  let rec seq = function
+    | [] -> return []
+    | x::xs -> 
+        x >>= fun x -> 
+        seq xs >>= fun xs ->
+        return (x::xs)
+
+  let rec seq_ = function
+    | [] -> return ()
+    | x::xs -> x >>= fun () -> seq_ xs
+
+  let mapM f ls = seq (List.map f ls)
+
+  let rec for_ i to_ f =
+    if i > to_ then return ()
+    else f i >>= fun () -> for_ (i+1) to_ f
+    
+  let iteri f ls = seq_ (Xlist.mapi f ls)
+
+end
+
+module Make2(M:S2) : T2 with type ('a, 'z) t = ('a, 'z) M.t = struct
+  include M
+
+  let map ~f t = bind t (fun x -> return (f x))
+
+  module Open_ = struct
+    let bind = M.bind
+    let (>>=) = M.bind
+    let (>>|) t f = map ~f t
+    let return = return
+
+    (* Applicative style *)
+    let ( ^<$> ) f t = map ~f t 
+    let ( /<*> ) = fun f a ->
+      f >>= fun f -> 
+      a >>= fun a ->
+      return (f a)
+  end
+  include Open_
+  module Open = struct
+    type ('a, 'z) t = ('a, 'z) M.t
+    include Open_
+  end
+
+  let ignore a = a >>= fun _ -> return ()
+  let void = ignore
+
+  let rec seq = function
+    | [] -> return []
+    | x::xs -> 
+        x >>= fun x -> 
+        seq xs >>= fun xs ->
+        return (x::xs)
+
+  let rec seq_unit = function
+    | [] -> return ()
+    | x::xs -> x >>= fun () -> seq_unit xs
+
+  let mapM f ls = seq (List.map f ls)
+
+  let rec for_ i to_ f =
+    if i > to_ then return ()
+    else f i >>= fun () -> for_ (i+1) to_ f
+    
+  let iteri f ls = seq_unit (Xlist.mapi f ls)
+
+end
+

File spotlib/monad.mli

+open Monad_intf
+module Make(M : S) : T with type 'a t = 'a M.t
+module Make2(M : S2) : T2 with type ('a, 'z) t = ('a, 'z) M.t

File spotlib/monad.o

Binary file added.

File spotlib/monad.spit

Binary file added.

File spotlib/monad.spot

Binary file added.

File spotlib/monad_intf.annot

Empty file added.

File spotlib/monad_intf.cmi

Binary file added.

File spotlib/monad_intf.cmo

Binary file added.

File spotlib/monad_intf.cmx

Binary file added.

File spotlib/monad_intf.ml

+(** Minimum monad interface *)
+module type S = sig
+  type +'a t
+  val return : 'a -> 'a t
+  val bind : 'a t -> ('a -> 'b t) -> 'b t
+end
+
+module type Open = sig
+  type +'a t
+  val bind : 'a t -> ('a -> 'b t) -> 'b t
+  val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
+  val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
+  val return : 'a -> 'a t
+    
+    (** Applicative style binops *)
+    
+  val (^<$>) : ('a -> 'b) -> 'a t -> 'b t
+    (** same as map, <$> in Haskell *)
+    
+  val (/<*>) : ('a -> 'b) t -> 'a t -> 'b t
+  (** <*> in Haskell *)
+end
+
+module type T = sig
+  include Open
+  module Open : Open with type 'a t = 'a t
+
+  val map : f:('a -> 'b) -> 'a t -> 'b t
+  (** fmap in Haskell *)
+
+  val ignore : 'a t -> unit t (* CR jfuruse: ignore is confusing with Pervasives.ignore. Probably it should be superceded by void *)
+  val void : 'a t -> unit t
+
+  val seq : 'a t list -> 'a list t
+    (** sequence in Haskell. Not tail recursive. *)
+  val seq_ : unit t list -> unit t
+    (** sequence_ in Haskell. Tail recursive. *)
+  val mapM : ('a -> 'b t) -> 'a list -> 'b list t
+    (** Not tail recursive *)
+  val iteri : (int -> 'a -> unit t) -> 'a list -> unit t
+  val for_ : int -> int -> (int -> unit t) -> unit t
+end
+
+module type S2 = sig
+  type ('a, 'z) t
+  val return : 'a -> ('a, 'z) t
+  val bind : ('a, 'z) t -> ('a -> ('b, 'z) t) -> ('b, 'z) t
+end
+
+module type Open2 = sig
+  type ('a, 'z) t
+  val bind : ('a, 'z) t -> ('a -> ('b, 'z) t) -> ('b, 'z) t
+  val ( >>= ) : ('a, 'z) t -> ('a -> ('b, 'z) t) -> ('b, 'z) t
+  val ( >>| ) : ('a, 'z) t -> ('a -> 'b) -> ('b, 'z) t
+  val return : 'a -> ('a, 'z) t
+    
+    (** Applicative style binops *)
+    
+  val (^<$>) : ('a -> 'b) -> ('a, 'z) t -> ('b, 'z) t
+    (** same as map, <$> in Haskell *)
+    
+  val (/<*>) : ('a -> 'b, 'z) t -> ('a, 'z) t -> ('b, 'z) t
+  (** <*> in Haskell *)
+end
+
+module type T2 = sig
+  include Open2
+  module Open : Open2 with type ('a, 'z) t = ('a, 'z) t
+
+  val map : f:('a -> 'b) -> ('a, 'z) t -> ('b, 'z) t
+    (** fmap in Haskell *)
+
+  val ignore : ('a, 'z) t -> (unit, 'z) t  (* CR jfuruse: ignore is confusing with Pervasives.ignore. Probably it should be superceded by void *)
+  val void : ('a, 'z) t -> (unit, 'z) t
+
+  val seq : ('a, 'z) t list -> ('a list, 'z) t
+    (** sequence in Haskell. Not tail recursive. *)
+  val seq_unit : (unit, 'z) t list -> (unit, 'z) t
+    (** sequence_ in Haskell. Tail recursive. *)
+  val mapM : ('a -> ('b, 'z) t) -> 'a list -> ('b list, 'z) t
+    (** Not tail recursive *)
+  val iteri : (int -> 'a -> (unit, 'z) t) -> 'a list -> (unit, 'z) t
+  val for_ : int -> int -> (int -> (unit, 'z) t) -> (unit, 'z) t
+end

File spotlib/monad_intf.o

Binary file added.

File spotlib/monad_intf.spot

Binary file added.

File spotlib/xformat.annot

+"xformat.ml" 5 33 37 "xformat.ml" 5 33 43
+type(
+  Format.formatter
+)
+ident(
+  def stdout "xformat.ml" 6 60 60 --
+)
+"xformat.ml" 5 33 46 "xformat.ml" 5 33 59
+type(
+  Format.formatter
+)
+ident(
+  ext_ref Format.std_formatter
+)
+"xformat.ml" 6 60 64 "xformat.ml" 6 60 70
+type(
+  Format.formatter
+)
+ident(
+  def stderr "xformat.ml" 8 88 88 --
+)
+"xformat.ml" 6 60 73 "xformat.ml" 6 60 86
+type(
+  Format.formatter
+)