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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
$ cat > module.ml << "EOF"
> module M (S : S) =
> F.Make(struct
> module G = struct
> type t
> include Foo with type t := t
> include Bar with type t := t
> end
> end)
>
> module M =
> struct
> type t
> end
>
> module Update : sig
> val f : ('a, 'b) t -> 'a -> unit
> val g : ('a, 'b) t -> 'a -> unit
> module M : C with type k = t
> module G : C with type k := f
> type t
> end = struct
> type t = int
> end
>
> module M : S
> with type t = x
> and type t' = y
> and type t' = y
> =
> struct
> type t = int
> end
>
> module M : S with type t = x
> and type t' = y
> and type t' = y
> = struct
> type t = int
> end
>
> module Make: functor (M : T) -> sig
> val f : int -> int
> val g : int -> int
> end
>
> let _ = (module struct
> end)
>
> let _ =
> let _ = (module struct
> foo
> end)
>
> include (Bad : (module type of M
> with module N = O))
>
> val debatable : (module Module.Sub
> with type t1 = t1'
> and type t2 = t2')
>
> (* Detection of [Let] vs [LetIn] inside a [struct]. *)
> module M = struct
> let indentation_after_fun =
> fun foo ->
> bar
> end
>
> (* Unfinished [struct] *)
> module Store (K: API.KEY) (V: API.VALUE) :
> API.STORE with module K = K
> and module V = V =
> struct
>
> module K = K
> EOF
$ ocp-indent module.ml
module M (S : S) =
F.Make(struct
module G = struct
type t
include Foo with type t := t
include Bar with type t := t
end
end)
module M =
struct
type t
end
module Update : sig
val f : ('a, 'b) t -> 'a -> unit
val g : ('a, 'b) t -> 'a -> unit
module M : C with type k = t
module G : C with type k := f
type t
end = struct
type t = int
end
module M : S
with type t = x
and type t' = y
and type t' = y
=
struct
type t = int
end
module M : S with type t = x
and type t' = y
and type t' = y
= struct
type t = int
end
module Make: functor (M : T) -> sig
val f : int -> int
val g : int -> int
end
let _ = (module struct
end)
let _ =
let _ = (module struct
foo
end)
include (Bad : (module type of M
with module N = O))
val debatable : (module Module.Sub
with type t1 = t1'
and type t2 = t2')
(* Detection of [Let] vs [LetIn] inside a [struct]. *)
module M = struct
let indentation_after_fun =
fun foo ->
bar
end
(* Unfinished [struct] *)
module Store (K: API.KEY) (V: API.VALUE) :
API.STORE with module K = K
and module V = V =
struct
module K = K
|
