blob: bd2b9da5e959e1d8b1eb48fb866115c56383ad0b (
plain)
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
(* TEST
{
toplevel;
}{
toplevel with principal;
}
*)
module Foobar : sig
type t = private int
end = struct
type t = int
end;;
module F0 : sig type t = private int end = Foobar;;
let f (x : F0.t) = (x : Foobar.t);; (* fails *)
module F = Foobar;;
let f (x : F.t) = (x : Foobar.t);;
module M = struct type t = <m:int> end;;
module M1 : sig type t = private <m:int; ..> end = M;;
module M2 : sig type t = private <m:int; ..> end = M1;;
fun (x : M1.t) -> (x : M2.t);; (* fails *)
module M3 : sig type t = private M1.t end = M1;;
fun x -> (x : M3.t :> M1.t);;
fun x -> (x : M3.t :> M.t);;
module M4 : sig type t = private M3.t end = M2;; (* fails *)
module M4 : sig type t = private M3.t end = M;; (* fails *)
module M4 : sig type t = private M3.t end = M1;; (* might be ok *)
module M5 : sig type t = private M1.t end = M3;;
module M6 : sig type t = private < n:int; .. > end = M1;; (* fails *)
module Bar : sig type t = private Foobar.t val f : int -> t end =
struct type t = int let f (x : int) = (x : t) end;; (* must fail *)
module M : sig
type t = private T of int
val mk : int -> t
end = struct
type t = T of int
let mk x = T(x)
end;;
module M1 : sig
type t = M.t
val mk : int -> t
end = struct
type t = M.t
let mk = M.mk
end;;
module M2 : sig
type t = M.t
val mk : int -> t
end = struct
include M
end;;
module M3 : sig
type t = M.t
val mk : int -> t
end = M;;
module M4 : sig
type t = M.t = T of int
val mk : int -> t
end = M;;
(* Error: The variant or record definition does not match that of type M.t *)
module M5 : sig
type t = M.t = private T of int
val mk : int -> t
end = M;;
module M6 : sig
type t = private T of int
val mk : int -> t
end = M;;
module M' : sig
type t_priv = private T of int
type t = t_priv
val mk : int -> t
end = struct
type t_priv = T of int
type t = t_priv
let mk x = T(x)
end;;
module M3' : sig
type t = M'.t
val mk : int -> t
end = M';;
module M : sig type 'a t = private T of 'a end =
struct type 'a t = T of 'a end;;
module M1 : sig type 'a t = 'a M.t = private T of 'a end =
struct type 'a t = 'a M.t = private T of 'a end;;
(* PR#6090 *)
module Test = struct type t = private A end
module Test2 : module type of Test with type t = Test.t = Test;;
let f (x : Test.t) = (x : Test2.t);;
let f Test2.A = ();;
let a = Test2.A;; (* fail *)
(* The following should fail from a semantical point of view,
but allow it for backward compatibility *)
module Test2 : module type of Test with type t = private Test.t = Test;;
(* PR#6331 *)
type t = private < x : int; .. > as 'a;;
type t = private (< x : int; .. > as 'a) as 'a;;
type t = private < x : int > as 'a;;
type t = private (< x : int > as 'a) as 'b;;
type 'a t = private < x : int; .. > as 'a;;
type 'a t = private 'a constraint 'a = < x : int; .. >;;
(* PR#7437 *)
type t = [` Closed ];;
type nonrec t = private [> t];;
|
