1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
open Tests_defs
let r1 =
begin
let map : r1 -> r1 = Functor_r1.map in
let x = {r1_l1 = 2; r1_l2 = 12} in
assert (map x = x);
end
let intseq =
begin
let map : intseq -> intseq = Functor_intseq.map in
let i = ICons (0, ICons (1, ICons (2, INil))) in
assert (map i = i);
end
let seq =
begin
let map =
let module M : sig val map : ('a -> 'b) -> 'a seq -> 'b seq end
= struct let map = Functor_seq.map end in M.map in
assert (map ((+)1) (Cons (1, Cons (2, Cons (3, Cons (4, Nil)))))
= Cons (2, Cons (3, Cons (4, Cons (5, Nil)))));
end
let poly7 =
begin
let map =
let module M : sig val map : ('a -> 'b) -> 'a poly7 -> 'b poly7 end
= struct let map = Functor_poly7.map end in M.map in
assert (map ((+)1) (Foo (`F 0)) = Foo (`F 1));
end
let poly8 =
begin
let map =
let module M : sig val map : ('a -> 'b) -> 'a poly8 -> 'b poly8 end
= struct let map = Functor_poly8.map end in M.map in
assert (map ((+)1)
{ x = `G (`H (`I (Foo (`F 0))))}
= { x = `G (`H (`I (Foo (`F 1))))});
end
let poly10 =
begin
let map : poly10 -> poly10 = Functor_poly10.map in
assert (map `F = `F);
assert (map (`Cons (1,`Cons (2, `Nil))) = (`Cons (1,`Cons (2, `Nil))));
end
let pmutrec =
begin
let _ =
let module M : sig val map : ('a -> 'b) -> ('c -> 'd) -> ('a,'c) pmutrec_a -> ('b,'d) pmutrec_a end
= struct let map = Functor_pmutrec_a.map end in M.map in
let _ =
let module M : sig val map : ('a -> 'b) -> ('c -> 'd) -> ('a,'c) pmutrec_b -> ('b,'d) pmutrec_b end
= struct let map = Functor_pmutrec_b.map end in M.map in
let _ =
let module M : sig val map : ('a -> 'b) -> ('c -> 'd) -> ('a,'c) pmutrec_c -> ('b,'d) pmutrec_c end
= struct let map = Functor_pmutrec_c.map end in M.map in
let _ =
let module M : sig val map : ('a -> 'b) -> ('c -> 'd) -> ('a,'c) pmutrec_d -> ('b,'d) pmutrec_d end
= struct let map = Functor_pmutrec_d.map end in M.map in
()
end
let ff1 =
begin
let map =
let module M : sig val map : ('a -> 'b) -> 'a ff1 -> 'b ff1 end
= struct let map = Functor_ff1.map end in M.map in
assert (map ((+)1) (F (1,2)) = F (2,3));
assert (map ((+)1) (G 3) = G 3);
end
let ff2 =
begin
let map f =
let module M : sig val map : ('a -> 'b) -> ('c -> 'd) -> ('a,'c) ff2 -> ('b,'d) ff2 end
= struct let map = Functor_ff2.map end in M.map f in
assert (map ((+)1) not (F1 (F2 (Cons (1,Cons (2, Nil)), 3, Some true)))
= (F1 (F2 (Cons (2,Cons (3, Nil)), 3, Some false))));
assert (map not ((+)1) (F1 (F2 (Cons (true,Nil), 3, Some 0)))
= (F1 (F2 (Cons (false,Nil), 3, Some 1))));
end
(*
type 'a constrained = [`F of 'a] constraint 'a = int
*)
let t =
begin
let map : int -> int = Functor_t.map in
assert (map 12 = 12);
end
|
