jon.recoil.org
Testing of the @doc-json output
Merge branch 'sherlodoc-markdown'
# Conflicts:
# odoc-scrollycode-extension/src/scrollycode_extension.ml
+2
-2
day10/bin/combine_docs.ml
+2
-2
day10/bin/combine_docs.ml
···
85
85
end
86
86
87
87
(** Extract universe hash from html_path.
88
-
Path format: .../prep/universes/{universe}/{pkg}/{version}/html *)
88
+
Path format: [.../prep/universes/<universe>/<pkg>/<version>/html] *)
89
89
let extract_universe html_path =
90
90
let parts = String.split_on_char '/' html_path in
91
91
let rec find_after_universes = function
···
120
120
None
121
121
with _ -> None
122
122
123
-
(** Check if a directory name is a doc layer (doc-{hash}, but not doc-driver- or doc-odoc-) *)
123
+
(** Check if a directory name is a doc layer ([doc-<hash>], but not [doc-driver-] or [doc-odoc-]) *)
124
124
let is_doc_layer_dir name =
125
125
let len = String.length name in
126
126
len > 4 && String.sub name 0 4 = "doc-"
+1
-1
day10/bin/jtw_tools.ml
+1
-1
day10/bin/jtw_tools.ml
···
3
3
Per OCaml version: installs js_of_ocaml and js_top_worker (pinned from
4
4
a git repo), builds worker.js, and extracts stdlib cmis + dynamic_cmis.json.
5
5
6
-
Cached as jtw-tools-{hash}/ per OCaml version + repo + branch. *)
6
+
Cached as [jtw-tools-<hash>/] per OCaml version + repo + branch. *)
7
7
8
8
(** Compute hash for the jtw-tools layer.
9
9
Depends on OCaml version, repo, and branch. *)
+1
-1
day10/bin/linux.ml
+1
-1
day10/bin/linux.ml
···
396
396
(** Run odoc_driver_voodoo in a container.
397
397
398
398
This runs odoc_driver_voodoo which:
399
-
- Finds packages in prep/universes/{u}/{pkg}/{v}/
399
+
- Finds packages in [prep/universes/<u>/<pkg>/<v>/]
400
400
- Compiles .cmti/.cmt to .odoc with marker files
401
401
- Links and generates HTML
402
402
- Uses marker files to find dependencies
+7
-5
day10/bin/odoc_gen.ml
+7
-5
day10/bin/odoc_gen.ml
···
5
5
compile/link/html steps internally.
6
6
7
7
Per-package prep structure (deleted after odoc compile):
8
-
layer/prep/universes/{u}/{p}/{v}/
9
-
lib/ # .cmti/.cmt/.ml/.mli files (copied from opam lib)
10
-
doc/ # .mld files (copied from opam doc)
8
+
[layer/prep/universes/<u>/<p>/<v>/]
9
+
[lib/] - .cmti/.cmt/.ml/.mli files (copied from opam lib)
10
+
[doc/] - .mld files (copied from opam doc)
11
11
12
12
Accumulated odoc output (persists in layer overlay):
13
13
/home/opam/compile/ # .odoc files, visible to downstream packages
14
14
15
15
HTML output (bind-mounted shared directory):
16
-
/html/p/{pkg}/{version}/ # blessed packages
17
-
/html/u/{universe}/{pkg}/{version}/ # non-blessed packages *)
16
+
{[
17
+
/html/p/<pkg>/<version>/ (blessed packages)
18
+
/html/u/<universe>/<pkg>/<version>/ (non-blessed packages)
19
+
]} *)
18
20
19
21
type doc_result =
20
22
| Doc_success of { html_path : string; blessed : bool }
+2
-2
day10/bin/os.ml
+2
-2
day10/bin/os.ml
···
529
529
530
530
This module provides atomic swap operations for documentation directories,
531
531
implementing the "fresh docs with graceful degradation" pattern:
532
-
- Write new docs to a staging directory ({dir}.new)
533
-
- On success, atomically swap: old -> .old, new -> current, remove .old
532
+
- Write new docs to a staging directory ([dir.new])
533
+
- On success, atomically swap: old -> [.old], new -> current, remove [.old]
534
534
- On failure, leave original docs untouched
535
535
536
536
Recovery: On startup, clean up any stale .new or .old directories left
+2
-2
day10/bin/sync_docs.ml
+2
-2
day10/bin/sync_docs.ml
···
11
11
}
12
12
13
13
(** Extract universe hash from html_path.
14
-
Path format: .../prep/universes/{universe}/{pkg}/{version}/html *)
14
+
Path format: [.../prep/universes/<universe>/<pkg>/<version>/html] *)
15
15
let extract_universe html_path =
16
16
let parts = String.split_on_char '/' html_path in
17
17
let rec find_after_universes = function
···
42
42
with
43
43
| _ -> None
44
44
45
-
(** Check if a directory name is a doc layer (doc-{hash}, but not doc-driver- or doc-odoc-) *)
45
+
(** Check if a directory name is a doc layer ([doc-<hash>], but not [doc-driver-] or [doc-odoc-]) *)
46
46
let is_doc_layer_dir name =
47
47
let len = String.length name in
48
48
len > 4 && String.sub name 0 4 = "doc-"
+1
-1
day10/bin/util.ml
+1
-1
day10/bin/util.ml
···
41
41
in
42
42
Yojson.Safe.to_file name (`Assoc fields)
43
43
44
-
(** Ensure a symlink exists from packages/{pkg_str}/{layer_name} -> ../../{layer_name}
44
+
(** Ensure a symlink exists from [packages/<pkg_str>/<layer_name>] to [../../<layer_name>].
45
45
This enables tracking all builds/docs for a package.version. *)
46
46
let ensure_package_layer_symlink ~cache_dir ~os_key ~pkg_str ~layer_name =
47
47
let pkg_dir = Path.(cache_dir / os_key / "packages" / pkg_str) in
+5
-5
day10/lib/atomic_swap.ml
+5
-5
day10/lib/atomic_swap.ml
···
2
2
3
3
This module provides atomic swap operations for documentation directories,
4
4
implementing the "fresh docs with graceful degradation" pattern:
5
-
- Write new docs to a staging directory ({dir}.new)
6
-
- On success, atomically swap: old -> .old, new -> current, remove .old
5
+
- Write new docs to a staging directory ([dir.new])
6
+
- On success, atomically swap: old -> [.old], new -> current, remove [.old]
7
7
- On failure, leave original docs intact
8
8
9
9
This is a standalone module that can be used for testing without
···
89
89
90
90
(** Get paths for atomic swap operations.
91
91
Returns (staging_dir, final_dir, old_dir) where:
92
-
- staging_dir: {version}.new - where new docs are written
93
-
- final_dir: {version} - the live docs location
94
-
- old_dir: {version}.old - backup during swap *)
92
+
- staging_dir: [<version>.new] - where new docs are written
93
+
- final_dir: [<version>] - the live docs location
94
+
- old_dir: [<version>.old] - backup during swap *)
95
95
let get_swap_paths ~html_dir ~pkg ~version ~blessed ~universe =
96
96
let base_dir =
97
97
if blessed then
+5
-3
day10/lib/build_lock.ml
+5
-3
day10/lib/build_lock.ml
···
4
4
providing reliable "in progress" detection without stale state.
5
5
6
6
Lock file naming:
7
-
locks/build-{package}.{version}-{universe}.lock
8
-
locks/doc-{package}.{version}-{universe}.lock
9
-
locks/tool-{name}.lock or locks/tool-{name}-{ocaml_version}.lock
7
+
{[
8
+
locks/build-<package>.<version>-<universe>.lock
9
+
locks/doc-<package>.<version>-<universe>.lock
10
+
locks/tool-<name>.lock or locks/tool-<name>-<ocaml_version>.lock
11
+
]}
10
12
11
13
This module provides query functions for the web UI. The actual lock
12
14
acquisition is done by Os.create_directory_exclusively in bin/os.ml. *)
+6
-4
day10/lib/run_log.ml
+6
-4
day10/lib/run_log.ml
···
1
1
(** Run logging for batch processing.
2
2
3
3
Manages timestamp-based run directories with structured logs:
4
-
- runs/{id}/summary.json
5
-
- runs/{id}/build/{package}.log
6
-
- runs/{id}/docs/{package}.log
7
-
- latest -> runs/{id} (symlink)
4
+
{[
5
+
runs/<id>/summary.json
6
+
runs/<id>/build/<package>.log
7
+
runs/<id>/docs/<package>.log
8
+
latest -> runs/<id> (symlink)
9
+
]}
8
10
*)
9
11
10
12
(** Run metadata *)
+8
-6
day10/web/data/layer_data.ml
+8
-6
day10/web/data/layer_data.ml
···
1
1
(** Read layer info for packages from day10's cache directory.
2
-
Uses the packages/{pkg}/ directory structure with symlinks:
3
-
- build-{hash} -> ../../build-{hash} (all builds)
4
-
- doc-{hash} -> ../../doc-{hash} (all docs)
5
-
- blessed-build -> ../../build-{hash} (canonical build if blessed)
6
-
- blessed-docs -> ../../doc-{hash} (canonical docs if blessed)
7
-
Falls back to scanning build-* directories if no symlinks exist. *)
2
+
Uses the [packages/<pkg>/] directory structure with symlinks:
3
+
{[
4
+
build-<hash> -> ../../build-<hash> (all builds)
5
+
doc-<hash> -> ../../doc-<hash> (all docs)
6
+
blessed-build -> ../../build-<hash> (canonical build if blessed)
7
+
blessed-docs -> ../../doc-<hash> (canonical docs if blessed)
8
+
]}
9
+
Falls back to scanning [build-*] directories if no symlinks exist. *)
8
10
9
11
type layer_info = {
10
12
package: string;
+1
-1
day10/web/views/live_log.ml
+1
-1
day10/web/views/live_log.ml
···
23
23
else
24
24
None
25
25
26
-
(** Try to find a completed layer log by looking in packages/{pkg_str}/ for layer symlinks *)
26
+
(** Try to find a completed layer log by looking in [packages/<pkg_str>/] for layer symlinks *)
27
27
let find_completed_layer_log ~cache_dir ~platform ~stage ~pkg_str =
28
28
let pkg_dir = Filename.concat (Filename.concat (Filename.concat cache_dir platform) "packages") pkg_str in
29
29
if not (Sys.file_exists pkg_dir) then None
+98
docs/plans/2026-02-19-sherlodoc-markdown-design.md
+98
docs/plans/2026-02-19-sherlodoc-markdown-design.md
···
1
+
# Sherlodoc Markdown Storage
2
+
3
+
## Problem
4
+
5
+
Sherlodoc stores documentation as pre-rendered HTML (`doc_html` field in `Entry.t`).
6
+
This is unsuitable for LLM/AI consumption and terminal CLI display, where markdown
7
+
is the natural format.
8
+
9
+
## Solution
10
+
11
+
Add a `doc_markdown : string` field to `Entry.t`, populated at index time using
12
+
odoc's markdown2 renderer (with LLM-specific improvements: fully qualified paths
13
+
and unified code blocks for type definitions).
14
+
15
+
## Approach: Dual storage (Approach 1)
16
+
17
+
Store both `doc_html` and `doc_markdown` in each entry. Compute both at index time.
18
+
No runtime conversion needed. Database size increase is modest since doc comments
19
+
are typically small.
20
+
21
+
## Changes
22
+
23
+
### 1. `db/entry.ml` — Add `doc_markdown` field
24
+
25
+
```ocaml
26
+
type t =
27
+
{ name : string
28
+
; rhs : string option
29
+
; url : string
30
+
; kind : Kind.t
31
+
; cost : int
32
+
; doc_html : string
33
+
; doc_markdown : string (* NEW *)
34
+
; pkg : Package.t
35
+
}
36
+
```
37
+
38
+
Update `v`, `pp`, `structural_compare` accordingly.
39
+
40
+
### 2. `odoc/src/search/` — Add markdown rendering for doc comments
41
+
42
+
Add a `markdown_string_of_doc` function that mirrors `html_string_of_doc`:
43
+
44
+
```
45
+
Comment.elements
46
+
-> Odoc_document.Comment.to_ir
47
+
-> Odoc_markdown.Generator.block
48
+
-> Renderer.to_string (Renderer.Block.Blocks blocks)
49
+
-> string
50
+
```
51
+
52
+
The search module's dune gains a dependency on `odoc_markdown`.
53
+
54
+
### 3. `index/load_doc.ml` — Populate `doc_markdown` at index time
55
+
56
+
In `register_entry`, compute `doc_markdown` alongside `doc_html`:
57
+
58
+
```ocaml
59
+
let doc_markdown =
60
+
match doc_txt with
61
+
| "" -> ""
62
+
| _ -> markdown_string_of_doc doc
63
+
in
64
+
```
65
+
66
+
The index dune gains a dependency on `odoc_markdown` (via the search module).
67
+
68
+
### 4. `cli/search.ml` — Default to markdown in CLI output
69
+
70
+
- Change `--print-docstring-html` to print `elt.doc_markdown` and rename to
71
+
`--print-docstring` (keeping `--print-docstring-html` for HTML output)
72
+
- When `--print-docstring` is set, print `elt.doc_markdown`
73
+
74
+
### 5. Storage scope
75
+
76
+
Marshal format only for now — it serializes `Entry.t` directly so adding a field
77
+
Just Works. JS and ancient formats can be extended later.
78
+
79
+
## What stays the same
80
+
81
+
- Suffix tree / type polarity indices — unchanged
82
+
- Search algorithm — unchanged
83
+
- `doc_html` field — kept for browser/HTML consumers
84
+
- Text tokenization for search indexing — still uses `Text.of_doc`
85
+
86
+
## LLM markdown improvements (cherry-picked from jonludlam/odoc)
87
+
88
+
These commits improve markdown quality for LLM consumption:
89
+
90
+
1. **Fully qualified paths** — `Foo.Bar.t` instead of just `t`
91
+
2. **Unified code blocks** — Type definitions rendered as single code blocks
92
+
with inline doc comments instead of fragmented separate blocks
93
+
3. **Record field types** — Proper extraction of all inline elements
94
+
95
+
## Dependencies
96
+
97
+
The `index` library needs `odoc_markdown` added to its dune dependencies.
98
+
The `db` library has no new dependencies.
+1
-1
dune-project
+1
-1
dune-project
-1
js_top_worker/idl/dune
-1
js_top_worker/idl/dune
+1
-1
js_top_worker/lib/findlibish.ml
+1
-1
js_top_worker/lib/findlibish.ml
···
128
128
(** Parse a findlib_index file (JSON or legacy text format) and return
129
129
the list of META file paths and universe paths.
130
130
131
-
JSON format: {"meta_files": ["path/to/META", ...], "universes": ["universe1", ...]}
131
+
JSON format: [{"meta_files": [...], "universes": [...]}]
132
132
133
133
meta_files: direct paths to META files
134
134
universes: paths to other universes (directories containing findlib_index) *)
+1
-1
odoc-scrollycode-extension/src/scrollycode_extension.ml
+1
-1
odoc-scrollycode-extension/src/scrollycode_extension.ml
···
4
4
externally via CSS custom properties defined in {!Scrollycode_css}
5
5
and set by theme files in {!Scrollycode_themes}.
6
6
7
-
Authoring format uses @scrolly custom tags with an ordered
7
+
Authoring format uses [@scrolly] custom tags with an ordered
8
8
list inside, where each list item is a tutorial step containing
9
9
a bold title, prose paragraphs, and a code block.
10
10
+29
-11
odoc/sherlodoc/cli/search.ml
+29
-11
odoc/sherlodoc/cli/search.ml
···
20
20
| Page -> "page"
21
21
| Impl -> "source"
22
22
23
-
let print_result ~print_cost ~print_docstring ~no_rhs (elt : Db.Entry.t) =
23
+
type docstring_format = No_docstring | Markdown | Html
24
+
25
+
let print_result ~print_cost ~docstring_format ~no_rhs (elt : Db.Entry.t) =
24
26
let cost = if print_cost then string_of_int elt.cost ^ " " else "" in
25
27
let typedecl_params =
26
28
(match elt.kind with
···
36
38
| Some _ when no_rhs -> ()
37
39
| Some rhs -> Format.fprintf h "%s" (Unescape.string rhs)
38
40
in
39
-
let docstring = if print_docstring then "\n" ^ elt.doc_html else "" in
41
+
let docstring =
42
+
match docstring_format with
43
+
| No_docstring -> ""
44
+
| Markdown -> "\n" ^ elt.doc_markdown
45
+
| Html -> "\n" ^ elt.doc_html
46
+
in
40
47
Format.printf "%s%s %s%s%a%s@." cost kind typedecl_params name pp_rhs elt.rhs docstring
41
48
42
49
let search
···
47
54
~no_rhs
48
55
~pretty_query
49
56
~time
50
-
~print_docstring
57
+
~docstring_format
51
58
query
52
59
=
53
60
let query = Query.{ query; packages = []; limit } in
···
58
65
match r with
59
66
| [] -> print_endline "[No results]"
60
67
| _ :: _ as results ->
61
-
List.iter (print_result ~print_cost ~print_docstring ~no_rhs) results ;
68
+
List.iter (print_result ~print_cost ~docstring_format ~no_rhs) results ;
62
69
flush stdout ;
63
70
if time then Format.printf "Search in %f@." (t1 -. t0)
64
71
···
69
76
~static_sort
70
77
~limit
71
78
~time
72
-
~print_docstring
79
+
~docstring_format
73
80
~db
74
81
=
75
82
Printf.printf "%ssearch>%s %!" "\027[0;36m" "\027[0;0m" ;
···
83
90
~no_rhs
84
91
~pretty_query
85
92
~time
86
-
~print_docstring
93
+
~docstring_format
87
94
query ;
88
95
search_loop
89
96
~print_cost
···
92
99
~static_sort
93
100
~limit
94
101
~time
95
-
~print_docstring
102
+
~docstring_format
96
103
~db
97
104
| exception End_of_file -> Printf.printf "\n%!"
98
105
···
105
112
pretty_query
106
113
time
107
114
print_docstring
115
+
print_docstring_html
108
116
db_format
109
117
db_filename
110
118
=
119
+
let docstring_format =
120
+
if print_docstring then Markdown
121
+
else if print_docstring_html then Html
122
+
else No_docstring
123
+
in
111
124
let module Storage = (val Db_store.storage_module db_format) in
112
125
let db = Storage.load db_filename in
113
126
match query with
···
120
133
~static_sort
121
134
~limit
122
135
~time
123
-
~print_docstring
136
+
~docstring_format
124
137
~db
125
138
| Some query ->
126
139
search
···
130
143
~static_sort
131
144
~limit
132
145
~time
133
-
~print_docstring
146
+
~docstring_format
134
147
~db
135
148
query
136
149
···
169
182
Arg.(value & flag & info [ "pretty-query" ] ~doc)
170
183
171
184
let print_docstring =
172
-
let doc = "Print the HTML of the docstring of the results" in
185
+
let doc = "Print the markdown docstring of the results" in
186
+
Arg.(value & flag & info [ "print-docstring" ] ~doc)
187
+
188
+
let print_docstring_html =
189
+
let doc = "Print the HTML docstring of the results" in
173
190
Arg.(value & flag & info [ "print-docstring-html" ] ~doc)
174
191
175
192
let term =
···
182
199
$ limit
183
200
$ pretty_query
184
201
$ print_time
185
-
$ print_docstring)
202
+
$ print_docstring
203
+
$ print_docstring_html)
+4
-2
odoc/sherlodoc/db/entry.ml
+4
-2
odoc/sherlodoc/db/entry.ml
···
53
53
; kind : Kind.t
54
54
; cost : int
55
55
; doc_html : string
56
+
; doc_markdown : string
56
57
; pkg : Package.t
57
58
}
58
59
59
-
let pp fmt { name; rhs; url; kind = _; cost; doc_html; pkg = _ } =
60
+
let pp fmt { name; rhs; url; kind = _; cost; doc_html; doc_markdown = _; pkg = _ } =
60
61
Format.fprintf
61
62
fmt
62
63
"{ name = %s ; rhs = %a ; url = %s ; kind = . ; cost = %d ; doc_html = %s ; pkg = . }\n"
···
150
151
let path = String.concat "/" (List.rev path) in
151
152
pkg_link ^ "/doc/" ^ path
152
153
153
-
let v ~name ~kind ~cost ~rhs ~doc_html ~url ~pkg () =
154
+
let v ~name ~kind ~cost ~rhs ~doc_html ~doc_markdown ~url ~pkg () =
154
155
{ name = non_empty_string name
155
156
; kind
156
157
; url = non_empty_string url
157
158
; cost
158
159
; doc_html = non_empty_string doc_html
160
+
; doc_markdown = non_empty_string doc_markdown
159
161
; pkg
160
162
; rhs = Option.map non_empty_string rhs
161
163
}
+2
odoc/sherlodoc/db/entry.mli
+2
odoc/sherlodoc/db/entry.mli
+2
-2
odoc/sherlodoc/db/type_polarity.mli
+2
-2
odoc/sherlodoc/db/type_polarity.mli
···
23
23
24
24
How is polarity computed exactly ? When you have [t -> u], the polarity of [t]
25
25
is inversed, and the polarity of [u] stays the same. A good example of this is
26
-
the type of {!Stdlib.Out_channel.with_open_gen} :
26
+
the type of [Out_channel.with_open_gen] :
27
27
28
28
{[
29
29
val with_open_gen : open_flag list -> int -> string -> (t -> 'a) -> 'a
···
32
32
Here the polarities are [-open_flag list], [-int], [-string], [+Out_channel.t],
33
33
[-'a] and [+'a]. The fact that we have [+Out_channel.t] might be puzzling at
34
34
first, because an [Out_channel.t] is not returned by the function, but
35
-
{!Stdlib.Out_channel.with_open_gen} is indeed one of the possible ways to create
35
+
[Out_channel.with_open_gen] is indeed one of the possible ways to create
36
36
an [Out_channel.t].
37
37
38
38
There is however a complication. If the user queries for [int -> int -> string],
+1
odoc/sherlodoc/index/dune
+1
odoc/sherlodoc/index/dune
+13
-1
odoc/sherlodoc/index/load_doc.ml
+13
-1
odoc/sherlodoc/index/load_doc.ml
···
185
185
| "" -> ""
186
186
| _ -> string_of_html (Html.of_doc doc)
187
187
in
188
+
let doc_markdown =
189
+
match doc_txt with
190
+
| "" -> ""
191
+
| _ ->
192
+
let config =
193
+
Odoc_markdown.Config.make ~root_url:None ~allow_html:false ()
194
+
in
195
+
let ir = Odoc_document.Comment.to_ir doc in
196
+
let blocks = Odoc_markdown.Generator.block ~config ~xref_base_uri:"" ir in
197
+
Odoc_markdown.Renderer.to_string
198
+
(Odoc_markdown.Renderer.Block.Blocks blocks)
199
+
in
188
200
let rhs = Html.rhs_of_kind kind in
189
201
let kind = convert_kind ~db entry in
190
202
let cost = cost ~name ~kind ~doc_html ~rhs ~cat ~favourite ~favoured_prefixes in
191
203
let url = Html.url entry in
192
-
let elt = Sherlodoc_entry.v ~name ~kind ~rhs ~doc_html ~cost ~url ~pkg () in
204
+
let elt = Sherlodoc_entry.v ~name ~kind ~rhs ~doc_html ~doc_markdown ~cost ~url ~pkg () in
193
205
if index_docstring then register_doc ~db elt doc_txt ;
194
206
if index_name && kind <> Doc then register_full_name ~db elt ;
195
207
if type_search then register_kind ~db elt
+1
-1
odoc/sherlodoc/query/test/test_succ.ml
+1
-1
odoc/sherlodoc/query/test/test_succ.ml
···
3
3
let pkg = Db.Entry.Package.v ~name:"" ~version:""
4
4
5
5
let elt cost =
6
-
Db.Entry.v ~cost ~name:"" ~kind:Db.Entry.Kind.Doc ~rhs:None ~doc_html:"" ~url:"" ~pkg ()
6
+
Db.Entry.v ~cost ~name:"" ~kind:Db.Entry.Kind.Doc ~rhs:None ~doc_html:"" ~doc_markdown:"" ~url:"" ~pkg ()
7
7
8
8
(** This module does the same thing as Succ, but its correctness is obvious
9
9
and its performance terrible. *)
+2
-2
odoc/sherlodoc/test/cram/link_in_docstring.t/run.t
+2
-2
odoc/sherlodoc/test/cram/link_in_docstring.t/run.t
···
4
4
$ export SHERLODOC_DB=db.bin
5
5
$ export SHERLODOC_FORMAT=marshal
6
6
$ sherlodoc index $(find . -name '*.odocl')
7
-
$ sherlodoc search --print-docstring "foo"
7
+
$ sherlodoc search --print-docstring-html "foo"
8
8
val A.foo : int
9
9
<div><p>This is a docstring with a <span>link</span></p></div>
10
-
$ sherlodoc search --print-docstring "bar"
10
+
$ sherlodoc search --print-docstring-html "bar"
11
11
val A.bar : int
12
12
<div><p>This is a docstring with a ref to <span><code>foo</code></span></p></div>
+15
odoc/sherlodoc/test/cram/markdown_docstring.t/a.mli
+15
odoc/sherlodoc/test/cram/markdown_docstring.t/a.mli
···
1
+
2
+
(** This is a docstring with a {{:https://sherlocode.com}link} *)
3
+
val foo : int
4
+
5
+
(** This is a docstring with a ref to {!foo} *)
6
+
val bar : int
7
+
8
+
(** [hello name] returns a greeting for [name].
9
+
10
+
For example:
11
+
{[
12
+
hello "world" = "Hello, world!"
13
+
]}
14
+
*)
15
+
val hello : string -> string
+40
odoc/sherlodoc/test/cram/markdown_docstring.t/run.t
+40
odoc/sherlodoc/test/cram/markdown_docstring.t/run.t
···
1
+
$ ocamlc -c a.mli -bin-annot -I .
2
+
$ odoc compile -I . a.cmti
3
+
$ odoc link -I . a.odoc
4
+
$ export SHERLODOC_DB=db.bin
5
+
$ export SHERLODOC_FORMAT=marshal
6
+
$ sherlodoc index $(find . -name '*.odocl')
7
+
8
+
Search without docstrings:
9
+
10
+
$ sherlodoc search "foo" 2>&1
11
+
val A.foo : int
12
+
13
+
Search with markdown docstrings:
14
+
15
+
$ sherlodoc search --print-docstring "foo" 2>&1
16
+
val A.foo : int
17
+
This is a docstring with a [link](https://sherlocode.com)
18
+
19
+
20
+
$ sherlodoc search --print-docstring "bar" 2>&1
21
+
val A.bar : int
22
+
This is a docstring with a ref to [`foo`](A.md#val-foo)
23
+
24
+
25
+
$ sherlodoc search --print-docstring "hello" 2>&1
26
+
val A.hello : string -> string
27
+
`hello name` returns a greeting for `name`.
28
+
29
+
For example:
30
+
31
+
```ocaml
32
+
hello "world" = "Hello, world!"
33
+
```
34
+
35
+
36
+
Search with HTML docstrings:
37
+
38
+
$ sherlodoc search --print-docstring-html "foo" 2>&1
39
+
val A.foo : int
40
+
<div><p>This is a docstring with a <span>link</span></p></div>
+48
-1
odoc/src/document/url.ml
+48
-1
odoc/src/document/url.ml
···
2
2
open Odoc_model.Names
3
3
module Root = Odoc_model.Root
4
4
5
+
let parent_is_module : Identifier.Id.signature -> bool = fun x ->
6
+
match x.iv with
7
+
| `Module _ -> true
8
+
| `ModuleType _ -> false
9
+
| `Parameter _ -> true
10
+
| `Result _ -> false
11
+
| `Root _ -> true
12
+
13
+
let rec name_aux : Identifier.t -> string list =
14
+
fun x ->
15
+
match x.iv with
16
+
| `Root (_, name) -> [ModuleName.to_string name]
17
+
| `Module (p, name) when parent_is_module p -> ModuleName.to_string name :: name_aux (p :> Identifier.t)
18
+
| `Module (_, name) -> [ModuleName.to_string name]
19
+
| `Parameter (_, name) -> [ModuleName.to_string name]
20
+
| `Result x -> name_aux (x :> Identifier.t)
21
+
| `ModuleType (p, name) when parent_is_module p -> ModuleTypeName.to_string name :: name_aux (p :> Identifier.t)
22
+
| `ModuleType (_, name) -> [ModuleTypeName.to_string name]
23
+
| `Type (p, name) when parent_is_module p -> TypeName.to_string name :: name_aux (p :> Identifier.t)
24
+
| `Type (_, name) -> [TypeName.to_string name]
25
+
| `Constructor (_, name) -> [ConstructorName.to_string name]
26
+
| `Field (_, name) -> [FieldName.to_string name]
27
+
| `UnboxedField (_, name) -> [UnboxedFieldName.to_string name]
28
+
| `Extension (_, name) -> [ExtensionName.to_string name]
29
+
| `ExtensionDecl (_, _, name) -> [ExtensionName.to_string name]
30
+
| `Exception (_, name) -> [ExceptionName.to_string name]
31
+
| `Value (_, name) -> [ValueName.to_string name]
32
+
| `Class (_, name) -> [TypeName.to_string name]
33
+
| `ClassType (_, name) -> [TypeName.to_string name]
34
+
| `Method (_, name) -> [MethodName.to_string name]
35
+
| `InstanceVariable (_, name) -> [InstanceVariableName.to_string name]
36
+
| `Label (_, name) -> [LabelName.to_string name]
37
+
| `SourcePage (_, name) -> [name]
38
+
| `SourceLocation (x, anchor) ->
39
+
[List.hd (name_aux (x :> Identifier.t)) ^ "#" ^ DefName.to_string anchor]
40
+
| `SourceLocationMod x -> name_aux (x :> Identifier.t)
41
+
| `SourceLocationInternal (x, anchor) ->
42
+
[List.hd (name_aux (x :> Identifier.t)) ^ "#" ^ LocalName.to_string anchor]
43
+
| `AssetFile (_, name) -> [AssetName.to_string name]
44
+
| `Page (_, name) -> [PageName.to_string name]
45
+
| `LeafPage (_, name) -> [PageName.to_string name]
46
+
47
+
let full_ident_name : [< Identifier.t_pv ] Identifier.id -> string = fun id ->
48
+
let segs = name_aux (id :> Identifier.t) in
49
+
String.concat "." (List.rev segs)
50
+
51
+
5
52
let render_path : Path.t -> string =
6
53
let rec render_resolved : Path.Resolved.t -> string =
7
54
let open Path.Resolved in
8
55
function
9
-
| `Identifier id -> Identifier.name id
56
+
| `Identifier id -> full_ident_name id
10
57
| `CoreType n -> TypeName.to_string n
11
58
| `OpaqueModule p -> render_resolved (p :> t)
12
59
| `OpaqueModuleType p -> render_resolved (p :> t)
+134
-16
odoc/src/markdown2/generator.ml
+134
-16
odoc/src/markdown2/generator.ml
···
305
305
match header with Some header -> Some header | None -> None
306
306
in
307
307
let inline_source = source inline_text_only code in
308
-
let code = [ String.concat ~sep:"" inline_source ] in
309
-
let block = Renderer.Block.Code_block { info_string; code } in
310
-
[ block ] @ to_markdown rest
308
+
let initial_code = String.concat ~sep:"" inline_source in
309
+
310
+
(* Check if the rest starts with Documented/Nested items - if so, combine them *)
311
+
(match rest with
312
+
| (Documented _ | Nested _) :: _ ->
313
+
let l, _, remaining_rest = take_descr rest in
314
+
(* Combine the initial code with the documented items *)
315
+
let combine_code_with_docs initial_code items =
316
+
let rec collect_lines acc = function
317
+
| [] -> List.rev acc
318
+
| { attrs = _; anchor = _; code; doc; markers = _ } :: rest ->
319
+
let code_line = match code with
320
+
| `D code ->
321
+
let inline_source = inline ~config ~resolve code in
322
+
let rec extract_all_text acc = function
323
+
| [] -> List.rev acc
324
+
| Renderer.Inline.Text s :: rest -> extract_all_text (s :: acc) rest
325
+
| Renderer.Inline.Code_span code_list :: rest ->
326
+
extract_all_text (String.concat ~sep:"" code_list :: acc) rest
327
+
| Renderer.Inline.Inlines inlines :: rest ->
328
+
extract_all_text (extract_all_text [] inlines @ acc) rest
329
+
| Renderer.Inline.Emphasis inner :: rest ->
330
+
extract_all_text (extract_all_text [] [inner] @ acc) rest
331
+
| Renderer.Inline.Strong_emphasis inner :: rest ->
332
+
extract_all_text (extract_all_text [] [inner] @ acc) rest
333
+
| Renderer.Inline.Link { text; _ } :: rest ->
334
+
extract_all_text (extract_all_text [] [text] @ acc) rest
335
+
| Renderer.Inline.Image { text; _ } :: rest ->
336
+
extract_all_text (extract_all_text [] [text] @ acc) rest
337
+
| _ :: rest -> extract_all_text acc rest
338
+
in
339
+
let code_text = String.concat ~sep:"" (extract_all_text [] inline_source) in
340
+
String.trim code_text
341
+
| `N n ->
342
+
(* For nested items, recursively process them *)
343
+
let nested_blocks = to_markdown n in
344
+
String.concat ~sep:"\n" (List.concat_map (function
345
+
| Renderer.Block.Code_block { code; _ } -> code
346
+
| _ -> []) nested_blocks)
347
+
in
348
+
let doc_comment = match doc with
349
+
| [] -> ""
350
+
| doc_blocks ->
351
+
let doc_text = String.concat ~sep:"" (block_text_only doc_blocks) in
352
+
let cleaned_text = String.trim doc_text in
353
+
if cleaned_text = "" then ""
354
+
else " (** " ^ cleaned_text ^ " *)"
355
+
in
356
+
let combined_line = code_line ^ doc_comment in
357
+
collect_lines (combined_line :: acc) rest
358
+
in
359
+
let constructor_lines = collect_lines [] items in
360
+
String.trim initial_code :: constructor_lines
361
+
in
362
+
let combined_lines = combine_code_with_docs initial_code l in
363
+
(* Also collect any trailing Code items (like closing ']' for polymorphic variants) *)
364
+
let rec collect_trailing_code items acc =
365
+
match items with
366
+
| (Code _ | Alternative _) :: _ ->
367
+
let code, _, remaining = take_code items in
368
+
let trailing_code = String.concat ~sep:"" (source inline_text_only code) in
369
+
collect_trailing_code remaining (String.trim trailing_code :: acc)
370
+
| rest -> (List.rev acc, rest)
371
+
in
372
+
let trailing_codes, final_rest = collect_trailing_code remaining_rest [] in
373
+
let all_lines = combined_lines @ trailing_codes in
374
+
if all_lines <> [] then
375
+
let combined_code = String.concat ~sep:"\n" all_lines in
376
+
let code_block = Renderer.Block.Code_block { info_string; code = [combined_code] } in
377
+
[code_block] @ to_markdown final_rest
378
+
else
379
+
let code = [ initial_code ] in
380
+
let block = Renderer.Block.Code_block { info_string; code } in
381
+
[ block ] @ to_markdown rest
382
+
| _ ->
383
+
let code = [ initial_code ] in
384
+
let block = Renderer.Block.Code_block { info_string; code } in
385
+
[ block ] @ to_markdown rest)
311
386
| Subpage subp :: _ -> subpage ~config ~resolve subp
312
387
| (Documented _ | Nested _) :: _ ->
313
388
let l, _, rest = take_descr t in
314
-
let one { attrs = _; anchor = _; code; doc; markers = _ } =
315
-
let content =
316
-
match code with
317
-
| `D code ->
318
-
let inline_source = inline ~config ~resolve code in
319
-
let inlines = Renderer.Inline.Inlines inline_source in
320
-
let block = Renderer.Block.Paragraph inlines in
321
-
[ block ]
322
-
| `N n -> to_markdown n
389
+
(* Combine code and documentation into a single code block with inline comments *)
390
+
let combine_code_with_docs items =
391
+
let rec collect_lines acc = function
392
+
| [] -> List.rev acc
393
+
| { attrs = _; anchor = _; code; doc; markers = _ } :: rest ->
394
+
let code_line = match code with
395
+
| `D code ->
396
+
let inline_source = inline ~config ~resolve code in
397
+
let rec extract_all_text acc = function
398
+
| [] -> List.rev acc
399
+
| Renderer.Inline.Text s :: rest -> extract_all_text (s :: acc) rest
400
+
| Renderer.Inline.Code_span code_list :: rest ->
401
+
extract_all_text (String.concat ~sep:"" code_list :: acc) rest
402
+
| Renderer.Inline.Inlines inlines :: rest ->
403
+
extract_all_text (extract_all_text [] inlines @ acc) rest
404
+
| Renderer.Inline.Emphasis inner :: rest ->
405
+
extract_all_text (extract_all_text [] [inner] @ acc) rest
406
+
| Renderer.Inline.Strong_emphasis inner :: rest ->
407
+
extract_all_text (extract_all_text [] [inner] @ acc) rest
408
+
| Renderer.Inline.Link { text; _ } :: rest ->
409
+
extract_all_text (extract_all_text [] [text] @ acc) rest
410
+
| Renderer.Inline.Image { text; _ } :: rest ->
411
+
extract_all_text (extract_all_text [] [text] @ acc) rest
412
+
| _ :: rest -> extract_all_text acc rest
413
+
in
414
+
let code_text = String.concat ~sep:"" (extract_all_text [] inline_source) in
415
+
String.trim code_text
416
+
| `N n ->
417
+
(* For nested items, recursively process them *)
418
+
let nested_blocks = to_markdown n in
419
+
String.concat ~sep:"\n" (List.concat_map (function
420
+
| Renderer.Block.Code_block { code; _ } -> code
421
+
| _ -> []) nested_blocks)
422
+
in
423
+
let doc_comment = match doc with
424
+
| [] -> ""
425
+
| doc_blocks ->
426
+
let doc_text = String.concat ~sep:"" (block_text_only doc_blocks) in
427
+
let cleaned_text = String.trim doc_text in
428
+
if cleaned_text = "" then ""
429
+
else " (** " ^ cleaned_text ^ " *)"
430
+
in
431
+
let combined_line = code_line ^ doc_comment in
432
+
collect_lines (combined_line :: acc) rest
323
433
in
324
-
let block_doc = block ~config ~resolve doc in
325
-
List.append content block_doc
434
+
collect_lines [] items
326
435
in
327
-
let all_blocks = List.concat_map one l in
328
-
all_blocks @ to_markdown rest
436
+
let combined_lines = combine_code_with_docs l in
437
+
if combined_lines <> [] then
438
+
let combined_code = String.concat ~sep:"\n" combined_lines in
439
+
let code_block = Renderer.Block.Code_block { info_string = None; code = [combined_code] } in
440
+
[code_block] @ to_markdown rest
441
+
else
442
+
to_markdown rest
329
443
in
330
444
to_markdown t
331
445
···
393
507
let inline ~config ~xref_base_uri b =
394
508
let resolve = Link.Base xref_base_uri in
395
509
inline ~config ~resolve b
510
+
511
+
let block ~config ~xref_base_uri b =
512
+
let resolve = Link.Base xref_base_uri in
513
+
block ~config ~resolve b
396
514
397
515
let filepath ~config url = Link.Path.as_filename ~config url
+6
odoc/src/markdown2/generator.mli
+6
odoc/src/markdown2/generator.mli
+1
-1
odoc/src/odoc/odoc_file.ml
+1
-1
odoc/src/odoc/odoc_file.ml
···
29
29
type t = { content : content; warnings : Odoc_model.Error.t list }
30
30
31
31
(** Written at the top of the files. Checked when loading. *)
32
-
let magic = "odoc-%%VERSION%%"
32
+
let magic = "odoc-3.0.0"
33
33
34
34
(** Exceptions while saving are allowed to leak. *)
35
35
let save_ file f =
+1
-1
odoc/test/generators/html/Functor-F1.html
+1
-1
odoc/test/generators/html/Functor-F1.html
···
30
30
<a href="#argument-1-Arg" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor-F1-argument-1-Arg.html">Arg</a></span>
33
-
<span> : <a href="Functor-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor-module-type-S.html">Functor.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
+1
-1
odoc/test/generators/html/Functor-F2.html
+1
-1
odoc/test/generators/html/Functor-F2.html
···
30
30
<a href="#argument-1-Arg" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor-F2-argument-1-Arg.html">Arg</a></span>
33
-
<span> : <a href="Functor-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor-module-type-S.html">Functor.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
+1
-1
odoc/test/generators/html/Functor-F3.html
+1
-1
odoc/test/generators/html/Functor-F3.html
···
30
30
<a href="#argument-1-Arg" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor-F3-argument-1-Arg.html">Arg</a></span>
33
-
<span> : <a href="Functor-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor-module-type-S.html">Functor.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
+1
-1
odoc/test/generators/html/Functor-F4.html
+1
-1
odoc/test/generators/html/Functor-F4.html
···
30
30
<a href="#argument-1-Arg" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor-F4-argument-1-Arg.html">Arg</a></span>
33
-
<span> : <a href="Functor-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor-module-type-S.html">Functor.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
+1
-1
odoc/test/generators/html/Functor-module-type-S1.html
+1
-1
odoc/test/generators/html/Functor-module-type-S1.html
···
30
30
<a href="#argument-1-_" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor-module-type-S1-argument-1-_.html">_</a></span>
33
-
<span> : <a href="Functor-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor-module-type-S.html">Functor.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
+11
-10
odoc/test/generators/html/Functor.html
+11
-10
odoc/test/generators/html/Functor.html
···
39
39
</span>
40
40
<span> = <span class="keyword">functor</span>
41
41
<span> (<a href="Functor-module-type-S1-argument-1-_.html">_</a>
42
-
: <a href="Functor-module-type-S.html">S</a>)
42
+
: <a href="Functor-module-type-S.html">Functor.S</a>)
43
43
<span class="arrow">-></span>
44
-
</span> <a href="Functor-module-type-S.html">S</a>
44
+
</span> <a href="Functor-module-type-S.html">Functor.S</a>
45
45
</span>
46
46
</code>
47
47
</div>
···
54
54
<a href="Functor-F1.html">F1</a>
55
55
</span>
56
56
<span> (<a href="Functor-F1-argument-1-Arg.html">Arg</a> :
57
-
<a href="Functor-module-type-S.html">S</a>) :
58
-
<a href="Functor-module-type-S.html">S</a>
57
+
<a href="Functor-module-type-S.html">Functor.S</a>) :
58
+
<a href="Functor-module-type-S.html">Functor.S</a>
59
59
</span>
60
60
</code>
61
61
</div>
···
68
68
<a href="Functor-F2.html">F2</a>
69
69
</span>
70
70
<span> (<a href="Functor-F2-argument-1-Arg.html">Arg</a> :
71
-
<a href="Functor-module-type-S.html">S</a>) :
72
-
<a href="Functor-module-type-S.html">S</a>
71
+
<a href="Functor-module-type-S.html">Functor.S</a>) :
72
+
<a href="Functor-module-type-S.html">Functor.S</a>
73
73
<span class="keyword">with</span>
74
74
<span><span class="keyword">type</span>
75
75
<a href="Functor-module-type-S.html#type-t">t</a> =
···
87
87
<a href="Functor-F3.html">F3</a>
88
88
</span>
89
89
<span> (<a href="Functor-F3-argument-1-Arg.html">Arg</a> :
90
-
<a href="Functor-module-type-S.html">S</a>) :
90
+
<a href="Functor-module-type-S.html">Functor.S</a>) :
91
91
<span class="keyword">sig</span> ... <span class="keyword">end</span>
92
92
</span>
93
93
</code>
···
101
101
<a href="Functor-F4.html">F4</a>
102
102
</span>
103
103
<span> (<a href="Functor-F4-argument-1-Arg.html">Arg</a> :
104
-
<a href="Functor-module-type-S.html">S</a>) :
105
-
<a href="Functor-module-type-S.html">S</a>
104
+
<a href="Functor-module-type-S.html">Functor.S</a>) :
105
+
<a href="Functor-module-type-S.html">Functor.S</a>
106
106
</span>
107
107
</code>
108
108
</div>
···
113
113
<code>
114
114
<span><span class="keyword">module</span>
115
115
<a href="Functor-F5.html">F5</a>
116
-
</span><span> () : <a href="Functor-module-type-S.html">S</a></span>
116
+
</span>
117
+
<span> () : <a href="Functor-module-type-S.html">Functor.S</a></span>
117
118
</code>
118
119
</div>
119
120
</div>
+2
-2
odoc/test/generators/html/Functor2-X.html
+2
-2
odoc/test/generators/html/Functor2-X.html
···
30
30
<a href="#argument-1-Y" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor2-X-argument-1-Y.html">Y</a></span>
33
-
<span> : <a href="Functor2-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor2-module-type-S.html">Functor2.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
···
39
39
<a href="#argument-2-Z" class="anchor"></a>
40
40
<code><span><span class="keyword">module</span> </span>
41
41
<span><a href="Functor2-X-argument-2-Z.html">Z</a></span>
42
-
<span> : <a href="Functor2-module-type-S.html">S</a></span>
42
+
<span> : <a href="Functor2-module-type-S.html">Functor2.S</a></span>
43
43
</code>
44
44
</div>
45
45
</div>
+2
-2
odoc/test/generators/html/Functor2-module-type-XF.html
+2
-2
odoc/test/generators/html/Functor2-module-type-XF.html
···
30
30
<a href="#argument-1-Y" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Functor2-module-type-XF-argument-1-Y.html">Y</a></span>
33
-
<span> : <a href="Functor2-module-type-S.html">S</a></span>
33
+
<span> : <a href="Functor2-module-type-S.html">Functor2.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
···
39
39
<a href="#argument-2-Z" class="anchor"></a>
40
40
<code><span><span class="keyword">module</span> </span>
41
41
<span><a href="Functor2-module-type-XF-argument-2-Z.html">Z</a></span>
42
-
<span> : <a href="Functor2-module-type-S.html">S</a></span>
42
+
<span> : <a href="Functor2-module-type-S.html">Functor2.S</a></span>
43
43
</code>
44
44
</div>
45
45
</div>
+13
-8
odoc/test/generators/html/Functor2.html
+13
-8
odoc/test/generators/html/Functor2.html
···
37
37
<a href="Functor2-X.html">X</a>
38
38
</span>
39
39
<span> (<a href="Functor2-X-argument-1-Y.html">Y</a> :
40
-
<a href="Functor2-module-type-S.html">S</a>) (
40
+
<a href="Functor2-module-type-S.html">Functor2.S</a>) (
41
41
<a href="Functor2-X-argument-2-Z.html">Z</a> :
42
-
<a href="Functor2-module-type-S.html">S</a>) :
42
+
<a href="Functor2-module-type-S.html">Functor2.S</a>) :
43
43
<span class="keyword">sig</span> ... <span class="keyword">end</span>
44
44
</span>
45
45
</code>
···
53
53
<span class="keyword">type</span>
54
54
<a href="Functor2-module-type-XF.html">XF</a>
55
55
</span>
56
-
<span> = <span class="keyword">functor</span>
56
+
<span> =
57
+
58
+
<span class="keyword">functor</span>
57
59
<span> (<a href="Functor2-module-type-XF-argument-1-Y.html">Y</a>
58
-
: <a href="Functor2-module-type-S.html">S</a>)
60
+
: <a href="Functor2-module-type-S.html">Functor2.S</a>)
59
61
<span class="arrow">-></span>
60
-
</span> <span class="keyword">functor</span>
62
+
</span>
63
+
64
+
<span class="keyword">functor</span>
61
65
<span> (<a href="Functor2-module-type-XF-argument-2-Z.html">Z</a>
62
-
: <a href="Functor2-module-type-S.html">S</a>)
66
+
: <a href="Functor2-module-type-S.html">Functor2.S</a>)
63
67
<span class="arrow">-></span>
64
-
</span> <span class="keyword">sig</span> ...
65
-
<span class="keyword">end</span>
68
+
</span>
69
+
70
+
<span class="keyword">sig</span> ... <span class="keyword">end</span>
66
71
</span>
67
72
</code>
68
73
</div>
+2
-1
odoc/test/generators/html/Functor_ml-Foo'.html
+2
-1
odoc/test/generators/html/Functor_ml-Foo'.html
···
41
41
<div class="spec type anchored" id="type-t">
42
42
<a href="#type-t" class="anchor"></a>
43
43
<code><span><span class="keyword">type</span> t</span>
44
-
<span> = <a href="Functor_ml-Bar.html#type-t">Bar.t</a></span>
44
+
<span> = <a href="Functor_ml-Bar.html#type-t">Functor_ml.Bar.t</a>
45
+
</span>
45
46
</code>
46
47
</div>
47
48
</div>
+3
-2
odoc/test/generators/html/Include-module-type-Dorminant_Module.html
+3
-2
odoc/test/generators/html/Include-module-type-Dorminant_Module.html
···
21
21
<summary class="spec include">
22
22
<code>
23
23
<span><span class="keyword">include</span>
24
-
<a href="Include-module-type-Inherent_Module.html">Inherent_Module
24
+
<a href="Include-module-type-Inherent_Module.html">
25
+
Include.Inherent_Module
25
26
</a>
26
27
</span>
27
28
</code>
···
33
34
<a href="#val-a" class="anchor"></a>
34
35
<code>
35
36
<span><span class="keyword">val</span> a :
36
-
<a href="Include.html#type-u">u</a>
37
+
<a href="Include.html#type-u">Include.u</a>
37
38
</span>
38
39
</code>
39
40
</div>
+1
-1
odoc/test/generators/html/Include-module-type-Inherent_Module.html
+1
-1
odoc/test/generators/html/Include-module-type-Inherent_Module.html
+12
-7
odoc/test/generators/html/Include.html
+12
-7
odoc/test/generators/html/Include.html
···
34
34
<summary class="spec include">
35
35
<code>
36
36
<span><span class="keyword">include</span>
37
-
<a href="Include-module-type-Not_inlined.html">Not_inlined</a>
37
+
<a href="Include-module-type-Not_inlined.html">Include.Not_inlined
38
+
</a>
38
39
</span>
39
40
</code>
40
41
</summary>
···
89
90
<code>
90
91
<span><span class="keyword">include</span>
91
92
<a href="Include-module-type-Not_inlined_and_closed.html">
92
-
Not_inlined_and_closed
93
+
Include.Not_inlined_and_closed
93
94
</a>
94
95
</span>
95
96
</code>
···
125
126
<code>
126
127
<span><span class="keyword">include</span>
127
128
<a href="Include-module-type-Not_inlined_and_opened.html">
128
-
Not_inlined_and_opened
129
+
Include.Not_inlined_and_opened
129
130
</a>
130
131
</span>
131
132
</code>
···
157
158
<summary class="spec include">
158
159
<code>
159
160
<span><span class="keyword">include</span>
160
-
<a href="Include-module-type-Inherent_Module.html">Inherent_Module
161
+
<a href="Include-module-type-Inherent_Module.html">
162
+
Include.Inherent_Module
161
163
</a>
162
164
</span>
163
165
</code>
···
184
186
<summary class="spec include">
185
187
<code>
186
188
<span><span class="keyword">include</span>
187
-
<a href="Include-module-type-Dorminant_Module.html">Dorminant_Module
189
+
<a href="Include-module-type-Dorminant_Module.html">
190
+
Include.Dorminant_Module
188
191
</a>
189
192
</span>
190
193
</code>
···
194
197
<summary class="spec include">
195
198
<code>
196
199
<span><span class="keyword">include</span>
197
-
<a href="Include-module-type-Inherent_Module.html">Inherent_Module
200
+
<a href="Include-module-type-Inherent_Module.html">
201
+
Include.Inherent_Module
198
202
</a>
199
203
</span>
200
204
</code>
···
205
209
<div class="spec value anchored" id="val-a">
206
210
<a href="#val-a" class="anchor"></a>
207
211
<code>
208
-
<span><span class="keyword">val</span> a : <a href="#type-u">u</a>
212
+
<span><span class="keyword">val</span> a :
213
+
<a href="#type-u">Include.u</a>
209
214
</span>
210
215
</code>
211
216
</div>
+4
-3
odoc/test/generators/html/Include2-Y_include_doc.html
+4
-3
odoc/test/generators/html/Include2-Y_include_doc.html
···
28
28
<span><span class="keyword">include</span>
29
29
<span class="keyword">module</span> <span class="keyword">type</span>
30
30
<span class="keyword">of</span> <span class="keyword">struct</span>
31
-
<span class="keyword">include</span> <a href="Include2-Y.html">Y</a>
32
-
<span class="keyword">end</span>
31
+
<span class="keyword">include</span>
32
+
<a href="Include2-Y.html">Include2.Y</a>
33
+
<span class="keyword">end</span>
33
34
</span>
34
35
</code>
35
36
</summary>
···
37
38
<div class="spec type anchored" id="type-t">
38
39
<a href="#type-t" class="anchor"></a>
39
40
<code><span><span class="keyword">type</span> t</span>
40
-
<span> = <a href="Include2-Y.html#type-t">Y.t</a></span>
41
+
<span> = <a href="Include2-Y.html#type-t">Include2.Y.t</a></span>
41
42
</code>
42
43
</div>
43
44
</div>
+4
-3
odoc/test/generators/html/Include2-Y_include_synopsis.html
+4
-3
odoc/test/generators/html/Include2-Y_include_synopsis.html
···
26
26
<span><span class="keyword">include</span>
27
27
<span class="keyword">module</span> <span class="keyword">type</span>
28
28
<span class="keyword">of</span> <span class="keyword">struct</span>
29
-
<span class="keyword">include</span> <a href="Include2-Y.html">Y</a>
30
-
<span class="keyword">end</span>
29
+
<span class="keyword">include</span>
30
+
<a href="Include2-Y.html">Include2.Y</a>
31
+
<span class="keyword">end</span>
31
32
</span>
32
33
</code>
33
34
</summary>
···
35
36
<div class="spec type anchored" id="type-t">
36
37
<a href="#type-t" class="anchor"></a>
37
38
<code><span><span class="keyword">type</span> t</span>
38
-
<span> = <a href="Include2-Y.html#type-t">Y.t</a></span>
39
+
<span> = <a href="Include2-Y.html#type-t">Include2.Y.t</a></span>
39
40
</code>
40
41
</div>
41
42
</div>
+3
-2
odoc/test/generators/html/Include2.html
+3
-2
odoc/test/generators/html/Include2.html
···
38
38
<span><span class="keyword">include</span>
39
39
<span class="keyword">module</span> <span class="keyword">type</span>
40
40
<span class="keyword">of</span> <span class="keyword">struct</span>
41
-
<span class="keyword">include</span> <a href="Include2-X.html">X</a>
42
-
<span class="keyword">end</span>
41
+
<span class="keyword">include</span>
42
+
<a href="Include2-X.html">Include2.X</a>
43
+
<span class="keyword">end</span>
43
44
</span>
44
45
</code>
45
46
</summary>
+3
-1
odoc/test/generators/html/Include_sections.html
+3
-1
odoc/test/generators/html/Include_sections.html
···
101
101
<summary class="spec include">
102
102
<code>
103
103
<span><span class="keyword">include</span>
104
-
<a href="Include_sections-module-type-Something.html">Something</a>
104
+
<a href="Include_sections-module-type-Something.html">
105
+
Include_sections.Something
106
+
</a>
105
107
</span>
106
108
</code>
107
109
</summary>
+8
-6
odoc/test/generators/html/Labels.html
+8
-6
odoc/test/generators/html/Labels.html
···
46
46
<div class="spec value anchored" id="val-f">
47
47
<a href="#val-f" class="anchor"></a>
48
48
<code>
49
-
<span><span class="keyword">val</span> f : <a href="#type-t">t</a>
49
+
<span><span class="keyword">val</span> f :
50
+
<a href="#type-t">Labels.t</a>
50
51
</span>
51
52
</code>
52
53
</div><div class="spec-doc"><p>Attached to value</p></div>
···
57
58
<code>
58
59
<span><span class="keyword">val</span> e :
59
60
<span>unit <span class="arrow">-></span></span>
60
-
<a href="#type-t">t</a>
61
+
<a href="#type-t">Labels.t</a>
61
62
</span>
62
63
</code>
63
64
</div><div class="spec-doc"><p>Attached to external</p></div>
···
120
121
<div class="spec type extension anchored" id="extension-decl-X">
121
122
<a href="#extension-decl-X" class="anchor"></a>
122
123
<code>
123
-
<span><span class="keyword">type</span> <a href="#type-x">x</a> +=
124
+
<span><span class="keyword">type</span> <a href="#type-x">Labels.x</a>
125
+
+=
124
126
</span>
125
127
</code>
126
128
<ol>
···
137
139
<a href="#module-S" class="anchor"></a>
138
140
<code>
139
141
<span><span class="keyword">module</span> S :=
140
-
<a href="Labels-A.html">A</a>
142
+
<a href="Labels-A.html">Labels.A</a>
141
143
</span>
142
144
</code>
143
145
</div><div class="spec-doc"><p>Attached to module subst</p></div>
···
146
148
<div class="spec type subst anchored" id="type-s">
147
149
<a href="#type-s" class="anchor"></a>
148
150
<code><span><span class="keyword">type</span> s</span>
149
-
<span> := <a href="#type-t">t</a></span>
151
+
<span> := <a href="#type-t">Labels.t</a></span>
150
152
</code>
151
153
</div><div class="spec-doc"><p>Attached to type subst</p></div>
152
154
</div>
···
176
178
<ol>
177
179
<li id="type-v.f" class="def record field anchored">
178
180
<a href="#type-v.f" class="anchor"></a>
179
-
<code><span>f : <a href="#type-t">t</a>;</span></code>
181
+
<code><span>f : <a href="#type-t">Labels.t</a>;</span></code>
180
182
<div class="def-doc"><span class="comment-delim">(*</span>
181
183
<p>Attached to field</p><span class="comment-delim">*)</span>
182
184
</div>
+1
-1
odoc/test/generators/html/Module-module-type-S7.html
+1
-1
odoc/test/generators/html/Module-module-type-S7.html
···
47
47
<div class="spec module anchored" id="module-M">
48
48
<a href="#module-M" class="anchor"></a>
49
49
<code><span><span class="keyword">module</span> M</span>
50
-
<span> = <a href="Module-M'.html">M'</a></span>
50
+
<span> = <a href="Module-M'.html">Module.M'</a></span>
51
51
</code>
52
52
</div>
53
53
</div>
+11
-11
odoc/test/generators/html/Module.html
+11
-11
odoc/test/generators/html/Module.html
···
59
59
<code>
60
60
<span><span class="keyword">module</span>
61
61
<span class="keyword">type</span> S2
62
-
</span><span> = <a href="Module-module-type-S.html">S</a></span>
62
+
</span><span> = <a href="Module-module-type-S.html">Module.S</a></span>
63
63
</code>
64
64
</div>
65
65
</div>
···
71
71
<span class="keyword">type</span>
72
72
<a href="Module-module-type-S3.html">S3</a>
73
73
</span>
74
-
<span> = <a href="Module-module-type-S.html">S</a>
74
+
<span> = <a href="Module-module-type-S.html">Module.S</a>
75
75
<span class="keyword">with</span>
76
76
<span><span class="keyword">type</span>
77
77
<a href="Module-module-type-S.html#type-t">t</a> = int
···
91
91
<span class="keyword">type</span>
92
92
<a href="Module-module-type-S4.html">S4</a>
93
93
</span>
94
-
<span> = <a href="Module-module-type-S.html">S</a>
94
+
<span> = <a href="Module-module-type-S.html">Module.S</a>
95
95
<span class="keyword">with</span>
96
96
<span><span class="keyword">type</span>
97
97
<a href="Module-module-type-S.html#type-t">t</a> := int
···
108
108
<span class="keyword">type</span>
109
109
<a href="Module-module-type-S5.html">S5</a>
110
110
</span>
111
-
<span> = <a href="Module-module-type-S.html">S</a>
111
+
<span> = <a href="Module-module-type-S.html">Module.S</a>
112
112
<span class="keyword">with</span>
113
113
<span><span class="keyword">type</span>
114
114
<span>'a <a href="Module-module-type-S.html#type-v">v</a></span>
···
135
135
<span class="keyword">type</span>
136
136
<a href="Module-module-type-S6.html">S6</a>
137
137
</span>
138
-
<span> = <a href="Module-module-type-S.html">S</a>
138
+
<span> = <a href="Module-module-type-S.html">Module.S</a>
139
139
<span class="keyword">with</span>
140
140
<span><span class="keyword">type</span>
141
141
<span>('a, 'b) <a href="Module-module-type-S.html#type-w">w</a>
···
143
143
<span>
144
144
<span>(<span class="type-var">'a</span>,
145
145
<span class="type-var">'b</span>)
146
-
</span> <a href="#type-result">result</a>
146
+
</span> <a href="#type-result">Module.result</a>
147
147
</span>
148
148
</span>
149
149
</span>
···
171
171
<span class="keyword">type</span>
172
172
<a href="Module-module-type-S7.html">S7</a>
173
173
</span>
174
-
<span> = <a href="Module-module-type-S.html">S</a>
174
+
<span> = <a href="Module-module-type-S.html">Module.S</a>
175
175
<span class="keyword">with</span>
176
176
<span><span class="keyword">module</span>
177
177
<a href="Module-module-type-S-M.html">M</a> =
178
-
<a href="Module-M'.html">M'</a>
178
+
<a href="Module-M'.html">Module.M'</a>
179
179
</span>
180
180
</span>
181
181
</code>
···
189
189
<span class="keyword">type</span>
190
190
<a href="Module-module-type-S8.html">S8</a>
191
191
</span>
192
-
<span> = <a href="Module-module-type-S.html">S</a>
192
+
<span> = <a href="Module-module-type-S.html">Module.S</a>
193
193
<span class="keyword">with</span>
194
194
<span><span class="keyword">module</span>
195
195
<a href="Module-module-type-S-M.html">M</a> :=
196
-
<a href="Module-M'.html">M'</a>
196
+
<a href="Module-M'.html">Module.M'</a>
197
197
</span>
198
198
</span>
199
199
</code>
···
209
209
</span>
210
210
<span> = <span class="keyword">module</span>
211
211
<span class="keyword">type</span> <span class="keyword">of</span>
212
-
<a href="Module-M'.html">M'</a>
212
+
<a href="Module-M'.html">Module.M'</a>
213
213
</span>
214
214
</code>
215
215
</div>
+10
-4
odoc/test/generators/html/Module_type_alias.html
+10
-4
odoc/test/generators/html/Module_type_alias.html
···
57
57
<span><span class="keyword">module</span>
58
58
<span class="keyword">type</span> D
59
59
</span>
60
-
<span> = <a href="Module_type_alias-module-type-A.html">A</a></span>
60
+
<span> =
61
+
<a href="Module_type_alias-module-type-A.html">Module_type_alias.A</a>
62
+
</span>
61
63
</code>
62
64
</div>
63
65
</div>
···
75
77
: <span class="keyword">sig</span> ...
76
78
<span class="keyword">end</span>)
77
79
<span class="arrow">-></span>
78
-
</span> <a href="Module_type_alias-module-type-B.html">B</a>
80
+
</span>
81
+
<a href="Module_type_alias-module-type-B.html">Module_type_alias.B</a>
79
82
</span>
80
83
</code>
81
84
</div>
···
94
97
: <span class="keyword">sig</span> ...
95
98
<span class="keyword">end</span>)
96
99
<span class="arrow">-></span>
97
-
</span> <a href="Module_type_alias-module-type-A.html">D</a>
100
+
</span>
101
+
<a href="Module_type_alias-module-type-A.html">Module_type_alias.D</a>
98
102
</span>
99
103
</code>
100
104
</div>
···
106
110
<span><span class="keyword">module</span>
107
111
<span class="keyword">type</span> I
108
112
</span>
109
-
<span> = <a href="Module_type_alias-module-type-B.html">B</a></span>
113
+
<span> =
114
+
<a href="Module_type_alias-module-type-B.html">Module_type_alias.B</a>
115
+
</span>
110
116
</code>
111
117
</div>
112
118
</div>
+1
-1
odoc/test/generators/html/Module_type_of-T.html
+1
-1
odoc/test/generators/html/Module_type_of-T.html
···
34
34
<div class="spec module anchored" id="module-M">
35
35
<a href="#module-M" class="anchor"></a>
36
36
<code><span><span class="keyword">module</span> M</span>
37
-
<span> = <a href="Module_type_of-X.html">X</a></span>
37
+
<span> = <a href="Module_type_of-X.html">Module_type_of.X</a></span>
38
38
</code>
39
39
</div>
40
40
</div>
+4
-3
odoc/test/generators/html/Module_type_of.html
+4
-3
odoc/test/generators/html/Module_type_of.html
···
49
49
<span><span class="keyword">module</span>
50
50
<a href="Module_type_of-T.html">T</a>
51
51
</span>
52
-
<span> : <a href="Module_type_of-module-type-S.html">S</a>
53
-
<span class="keyword">with</span>
52
+
<span> :
53
+
<a href="Module_type_of-module-type-S.html">Module_type_of.S</a>
54
+
<span class="keyword">with</span>
54
55
<span><span class="keyword">module</span>
55
56
<a href="Module_type_of-module-type-S-M.html">M</a> =
56
-
<a href="Module_type_of-X.html">X</a>
57
+
<a href="Module_type_of-X.html">Module_type_of.X</a>
57
58
</span>
58
59
</span>
59
60
</code>
+3
-1
odoc/test/generators/html/Module_type_subst-Basic-module-type-a.html
+3
-1
odoc/test/generators/html/Module_type_subst-Basic-module-type-a.html
···
24
24
<span><span class="keyword">module</span>
25
25
<span class="keyword">type</span> b
26
26
</span>
27
-
<span> = <a href="Module_type_subst-module-type-s.html">s</a></span>
27
+
<span> =
28
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s</a>
29
+
</span>
28
30
</code>
29
31
</div>
30
32
</div>
+3
-1
odoc/test/generators/html/Module_type_subst-Basic-module-type-c.html
+3
-1
odoc/test/generators/html/Module_type_subst-Basic-module-type-c.html
···
24
24
<span><span class="keyword">module</span>
25
25
<a href="Module_type_subst-Basic-module-type-c-M.html">M</a>
26
26
</span>
27
-
<span> : <a href="Module_type_subst-module-type-s.html">s</a></span>
27
+
<span> :
28
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s</a>
29
+
</span>
28
30
</code>
29
31
</div>
30
32
</div>
+3
-1
odoc/test/generators/html/Module_type_subst-Basic-module-type-with_.html
+3
-1
odoc/test/generators/html/Module_type_subst-Basic-module-type-with_.html
···
24
24
<span><span class="keyword">module</span>
25
25
<span class="keyword">type</span> T
26
26
</span>
27
-
<span> = <a href="Module_type_subst-module-type-s.html">s</a></span>
27
+
<span> =
28
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s</a>
29
+
</span>
28
30
</code>
29
31
</div>
30
32
</div>
+21
-8
odoc/test/generators/html/Module_type_subst-Basic.html
+21
-8
odoc/test/generators/html/Module_type_subst-Basic.html
···
38
38
<span class="keyword">type</span>
39
39
<a href="Module_type_subst-Basic-module-type-with_.html">with_</a>
40
40
</span>
41
-
<span> = <a href="Module_type_subst-Basic-module-type-u.html">u</a>
42
-
<span class="keyword">with</span>
41
+
<span> =
42
+
43
+
<a href="Module_type_subst-Basic-module-type-u.html">
44
+
Module_type_subst.Basic.u
45
+
</a> <span class="keyword">with</span>
43
46
<span><span class="keyword">module</span>
44
47
<span class="keyword">type</span>
45
48
<a href="Module_type_subst-Basic-module-type-u-module-type-T.html">T
46
-
</a> = <a href="Module_type_subst-module-type-s.html">s</a>
49
+
</a> =
50
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s
51
+
</a>
47
52
</span>
48
53
</span>
49
54
</code>
···
71
76
<span class="keyword">type</span>
72
77
<a href="Module_type_subst-Basic-module-type-with_2.html">with_2</a>
73
78
</span>
74
-
<span> = <a href="Module_type_subst-Basic-module-type-u2.html">u2</a>
75
-
<span class="keyword">with</span>
79
+
<span> =
80
+
81
+
<a href="Module_type_subst-Basic-module-type-u2.html">
82
+
Module_type_subst.Basic.u2
83
+
</a> <span class="keyword">with</span>
76
84
<span><span class="keyword">module</span>
77
85
<span class="keyword">type</span>
78
86
<a href="Module_type_subst-Basic-module-type-u2-module-type-T.html">T
···
105
113
<span class="keyword">type</span>
106
114
<a href="Module_type_subst-Basic-module-type-c.html">c</a>
107
115
</span>
108
-
<span> = <a href="Module_type_subst-Basic-module-type-a.html">a</a>
109
-
<span class="keyword">with</span>
116
+
<span> =
117
+
118
+
<a href="Module_type_subst-Basic-module-type-a.html">
119
+
Module_type_subst.Basic.a
120
+
</a> <span class="keyword">with</span>
110
121
<span><span class="keyword">module</span>
111
122
<span class="keyword">type</span>
112
123
<a href="Module_type_subst-Basic-module-type-a-module-type-b.html">b
113
-
</a> := <a href="Module_type_subst-module-type-s.html">s</a>
124
+
</a> :=
125
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s
126
+
</a>
114
127
</span>
115
128
</span>
116
129
</code>
+4
-1
odoc/test/generators/html/Module_type_subst-Local-module-type-local.html
+4
-1
odoc/test/generators/html/Module_type_subst-Local-module-type-local.html
···
21
21
<div class="spec type anchored" id="type-t">
22
22
<a href="#type-t" class="anchor"></a>
23
23
<code><span><span class="keyword">type</span> t</span>
24
-
<span> = <a href="Module_type_subst-Local.html#type-local">local</a>
24
+
<span> =
25
+
<a href="Module_type_subst-Local.html#type-local">
26
+
Module_type_subst.Local.local
27
+
</a>
25
28
</span>
26
29
</code>
27
30
</div>
+3
-1
odoc/test/generators/html/Module_type_subst-Local.html
+3
-1
odoc/test/generators/html/Module_type_subst-Local.html
+3
-1
odoc/test/generators/html/Module_type_subst-Nested-module-type-with_-N.html
+3
-1
odoc/test/generators/html/Module_type_subst-Nested-module-type-with_-N.html
···
27
27
<span><span class="keyword">module</span>
28
28
<span class="keyword">type</span> t
29
29
</span>
30
-
<span> = <a href="Module_type_subst-module-type-s.html">s</a></span>
30
+
<span> =
31
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s</a>
32
+
</span>
31
33
</code>
32
34
</div>
33
35
</div>
+16
-8
odoc/test/generators/html/Module_type_subst-Nested.html
+16
-8
odoc/test/generators/html/Module_type_subst-Nested.html
···
38
38
<span class="keyword">type</span>
39
39
<a href="Module_type_subst-Nested-module-type-with_.html">with_</a>
40
40
</span>
41
-
<span> =
42
-
<a href="Module_type_subst-Nested-module-type-nested.html">nested</a>
43
-
<span class="keyword">with</span>
41
+
<span> =
42
+
43
+
<a href="Module_type_subst-Nested-module-type-nested.html">
44
+
Module_type_subst.Nested.nested
45
+
</a> <span class="keyword">with</span>
44
46
<span><span class="keyword">module</span>
45
47
<span class="keyword">type</span>
46
48
<a
47
49
href="Module_type_subst-Nested-module-type-nested-N-module-type-t.html"
48
50
>N.t
49
-
</a> = <a href="Module_type_subst-module-type-s.html">s</a>
51
+
</a> =
52
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s
53
+
</a>
50
54
</span>
51
55
</span>
52
56
</code>
···
62
66
with_subst
63
67
</a>
64
68
</span>
65
-
<span> =
66
-
<a href="Module_type_subst-Nested-module-type-nested.html">nested</a>
67
-
<span class="keyword">with</span>
69
+
<span> =
70
+
71
+
<a href="Module_type_subst-Nested-module-type-nested.html">
72
+
Module_type_subst.Nested.nested
73
+
</a> <span class="keyword">with</span>
68
74
<span><span class="keyword">module</span>
69
75
<span class="keyword">type</span>
70
76
<a
71
77
href="Module_type_subst-Nested-module-type-nested-N-module-type-t.html"
72
78
>N.t
73
-
</a> := <a href="Module_type_subst-module-type-s.html">s</a>
79
+
</a> :=
80
+
<a href="Module_type_subst-module-type-s.html">Module_type_subst.s
81
+
</a>
74
82
</span>
75
83
</span>
76
84
</code>
+3
-2
odoc/test/generators/html/Module_type_subst-Structural.html
+3
-2
odoc/test/generators/html/Module_type_subst-Structural.html
···
39
39
<a href="Module_type_subst-Structural-module-type-w.html">w</a>
40
40
</span>
41
41
<span> =
42
-
<a href="Module_type_subst-Structural-module-type-u.html">u</a>
43
-
<span class="keyword">with</span>
42
+
<a href="Module_type_subst-Structural-module-type-u.html">
43
+
Module_type_subst.Structural.u
44
+
</a> <span class="keyword">with</span>
44
45
<span><span class="keyword">module</span>
45
46
<span class="keyword">type</span>
46
47
<a
+1
-1
odoc/test/generators/html/Nested-F-argument-1-Arg1.html
+1
-1
odoc/test/generators/html/Nested-F-argument-1-Arg1.html
···
34
34
<div class="spec value anchored" id="val-y">
35
35
<a href="#val-y" class="anchor"></a>
36
36
<code>
37
-
<span><span class="keyword">val</span> y : <a href="#type-t">t</a>
37
+
<span><span class="keyword">val</span> y : <a href="#type-t">Arg1.t</a>
38
38
</span>
39
39
</code>
40
40
</div><div class="spec-doc"><p>The value of y.</p></div>
+1
-1
odoc/test/generators/html/Nested-F.html
+1
-1
odoc/test/generators/html/Nested-F.html
···
32
32
<a href="#argument-1-Arg1" class="anchor"></a>
33
33
<code><span><span class="keyword">module</span> </span>
34
34
<span><a href="Nested-F-argument-1-Arg1.html">Arg1</a></span>
35
-
<span> : <a href="Nested-module-type-Y.html">Y</a></span>
35
+
<span> : <a href="Nested-module-type-Y.html">Nested.Y</a></span>
36
36
</code>
37
37
</div>
38
38
</div>
+2
-1
odoc/test/generators/html/Nested-X.html
+2
-1
odoc/test/generators/html/Nested-X.html
···
35
35
<div class="spec value anchored" id="val-x">
36
36
<a href="#val-x" class="anchor"></a>
37
37
<code>
38
-
<span><span class="keyword">val</span> x : <a href="#type-t">t</a>
38
+
<span><span class="keyword">val</span> x :
39
+
<a href="#type-t">Nested.X.t</a>
39
40
</span>
40
41
</code>
41
42
</div><div class="spec-doc"><p>The value of x.</p></div>
+1
-1
odoc/test/generators/html/Nested.html
+1
-1
odoc/test/generators/html/Nested.html
···
61
61
<span><span class="keyword">module</span> <a href="Nested-F.html">F</a>
62
62
</span>
63
63
<span> (<a href="Nested-F-argument-1-Arg1.html">Arg1</a> :
64
-
<a href="Nested-module-type-Y.html">Y</a>) (
64
+
<a href="Nested-module-type-Y.html">Nested.Y</a>) (
65
65
<a href="Nested-F-argument-2-Arg2.html">Arg2</a> :
66
66
<span class="keyword">sig</span> ... <span class="keyword">end</span>
67
67
) : <span class="keyword">sig</span> ...
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-E.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-E.html
···
28
28
<a href="#val-id" class="anchor"></a>
29
29
<code>
30
30
<span><span class="keyword">val</span> id :
31
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
32
-
</span> <a href="#type-t">t</a>
31
+
<span><a href="#type-t">Ocamlary.Aliases.E.t</a>
32
+
<span class="arrow">-></span>
33
+
</span> <a href="#type-t">Ocamlary.Aliases.E.t</a>
33
34
</span>
34
35
</code>
35
36
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-A.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-A.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.Foo.A.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.Foo.A.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-B.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-B.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.Foo.B.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.Foo.B.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-C.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-C.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.Foo.C.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.Foo.C.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-D.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-D.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.Foo.D.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.Foo.D.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-E.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-Foo-E.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.Foo.E.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.Foo.E.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-P1-Y.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-P1-Y.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.P1.Y.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.P1.Y.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-P2-Z.html
+3
-2
odoc/test/generators/html/Ocamlary-Aliases-P2-Z.html
···
29
29
<a href="#val-id" class="anchor"></a>
30
30
<code>
31
31
<span><span class="keyword">val</span> id :
32
-
<span><a href="#type-t">t</a> <span class="arrow">-></span>
33
-
</span> <a href="#type-t">t</a>
32
+
<span><a href="#type-t">Ocamlary.Aliases.P2.Z.t</a>
33
+
<span class="arrow">-></span>
34
+
</span> <a href="#type-t">Ocamlary.Aliases.P2.Z.t</a>
34
35
</span>
35
36
</code>
36
37
</div>
+3
-1
odoc/test/generators/html/Ocamlary-Aliases-Std.html
+3
-1
odoc/test/generators/html/Ocamlary-Aliases-Std.html
···
53
53
<div class="spec module anchored" id="module-E">
54
54
<a href="#module-E" class="anchor"></a>
55
55
<code><span><span class="keyword">module</span> E</span>
56
-
<span> = <a href="Ocamlary-Aliases-Foo-E.html">Foo.E</a></span>
56
+
<span> =
57
+
<a href="Ocamlary-Aliases-Foo-E.html">Ocamlary.Aliases.Foo.E</a>
58
+
</span>
57
59
</code>
58
60
</div>
59
61
</div>
+21
-8
odoc/test/generators/html/Ocamlary-Aliases.html
+21
-8
odoc/test/generators/html/Ocamlary-Aliases.html
···
56
56
<div class="spec type anchored" id="type-tbtb">
57
57
<a href="#type-tbtb" class="anchor"></a>
58
58
<code><span><span class="keyword">type</span> tbtb</span>
59
-
<span> = <a href="Ocamlary-Aliases-Foo-B.html#type-t">Foo.B.t</a>
59
+
<span> =
60
+
<a href="Ocamlary-Aliases-Foo-B.html#type-t">Ocamlary.Aliases.Foo.B.t
61
+
</a>
60
62
</span>
61
63
</code>
62
64
</div>
···
79
81
<div class="spec type anchored" id="type-tete2">
80
82
<a href="#type-tete2" class="anchor"></a>
81
83
<code><span><span class="keyword">type</span> tete2</span>
82
-
<span> = <a href="Ocamlary-Aliases-Foo-E.html#type-t">Foo.E.t</a>
84
+
<span> =
85
+
<a href="Ocamlary-Aliases-Foo-E.html#type-t">Ocamlary.Aliases.Foo.E.t
86
+
</a>
83
87
</span>
84
88
</code>
85
89
</div>
···
116
120
<span><span class="keyword">include</span>
117
121
<span class="keyword">module</span> <span class="keyword">type</span>
118
122
<span class="keyword">of</span>
119
-
<a href="Ocamlary-Aliases-Foo.html">Foo</a>
123
+
<a href="Ocamlary-Aliases-Foo.html">Ocamlary.Aliases.Foo</a>
120
124
</span>
121
125
</code>
122
126
</summary>
···
124
128
<div class="spec module anchored" id="module-A">
125
129
<a href="#module-A" class="anchor"></a>
126
130
<code><span><span class="keyword">module</span> A</span>
127
-
<span> = <a href="Ocamlary-Aliases-Foo-A.html">Foo.A</a></span>
131
+
<span> =
132
+
<a href="Ocamlary-Aliases-Foo-A.html">Ocamlary.Aliases.Foo.A</a>
133
+
</span>
128
134
</code>
129
135
</div>
130
136
</div>
···
132
138
<div class="spec module anchored" id="module-B">
133
139
<a href="#module-B" class="anchor"></a>
134
140
<code><span><span class="keyword">module</span> B</span>
135
-
<span> = <a href="Ocamlary-Aliases-Foo-B.html">Foo.B</a></span>
141
+
<span> =
142
+
<a href="Ocamlary-Aliases-Foo-B.html">Ocamlary.Aliases.Foo.B</a>
143
+
</span>
136
144
</code>
137
145
</div>
138
146
</div>
···
140
148
<div class="spec module anchored" id="module-C">
141
149
<a href="#module-C" class="anchor"></a>
142
150
<code><span><span class="keyword">module</span> C</span>
143
-
<span> = <a href="Ocamlary-Aliases-Foo-C.html">Foo.C</a></span>
151
+
<span> =
152
+
<a href="Ocamlary-Aliases-Foo-C.html">Ocamlary.Aliases.Foo.C</a>
153
+
</span>
144
154
</code>
145
155
</div>
146
156
</div>
···
148
158
<div class="spec module anchored" id="module-D">
149
159
<a href="#module-D" class="anchor"></a>
150
160
<code><span><span class="keyword">module</span> D</span>
151
-
<span> = <a href="Ocamlary-Aliases-Foo-D.html">Foo.D</a></span>
161
+
<span> =
162
+
<a href="Ocamlary-Aliases-Foo-D.html">Ocamlary.Aliases.Foo.D</a>
163
+
</span>
152
164
</code>
153
165
</div>
154
166
</div>
···
210
222
<div class="spec module anchored" id="module-X1">
211
223
<a href="#module-X1" class="anchor"></a>
212
224
<code><span><span class="keyword">module</span> X1</span>
213
-
<span> = <a href="Ocamlary-Aliases-P2-Z.html">P2.Z</a></span>
225
+
<span> = <a href="Ocamlary-Aliases-P2-Z.html">Ocamlary.Aliases.P2.Z</a>
226
+
</span>
214
227
</code>
215
228
</div>
216
229
</div>
+9
-4
odoc/test/generators/html/Ocamlary-CanonicalTest-Base-List.html
+9
-4
odoc/test/generators/html/Ocamlary-CanonicalTest-Base-List.html
···
30
30
<a href="#val-id" class="anchor"></a>
31
31
<code>
32
32
<span><span class="keyword">val</span> id :
33
+
33
34
<span>
34
-
<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>
35
-
<span class="arrow">-></span>
36
-
</span>
37
-
<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>
35
+
<span><span class="type-var">'a</span>
36
+
<a href="#type-t">Ocamlary.CanonicalTest.Base.List.t</a>
37
+
</span> <span class="arrow">-></span>
38
+
</span>
39
+
40
+
<span><span class="type-var">'a</span>
41
+
<a href="#type-t">Ocamlary.CanonicalTest.Base.List.t</a>
42
+
</span>
38
43
</span>
39
44
</code>
40
45
</div>
+9
-4
odoc/test/generators/html/Ocamlary-CanonicalTest-Base_Tests-C.html
+9
-4
odoc/test/generators/html/Ocamlary-CanonicalTest-Base_Tests-C.html
···
32
32
<a href="#val-id" class="anchor"></a>
33
33
<code>
34
34
<span><span class="keyword">val</span> id :
35
+
35
36
<span>
36
-
<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>
37
-
<span class="arrow">-></span>
38
-
</span>
39
-
<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>
37
+
<span><span class="type-var">'a</span>
38
+
<a href="#type-t">Ocamlary.CanonicalTest.Base_Tests.C.t</a>
39
+
</span> <span class="arrow">-></span>
40
+
</span>
41
+
42
+
<span><span class="type-var">'a</span>
43
+
<a href="#type-t">Ocamlary.CanonicalTest.Base_Tests.C.t</a>
44
+
</span>
40
45
</span>
41
46
</code>
42
47
</div>
+17
-6
odoc/test/generators/html/Ocamlary-CanonicalTest-Base_Tests.html
+17
-6
odoc/test/generators/html/Ocamlary-CanonicalTest-Base_Tests.html
···
27
27
</span>
28
28
<span> : <span class="keyword">module</span>
29
29
<span class="keyword">type</span> <span class="keyword">of</span>
30
-
<a href="Ocamlary-CanonicalTest-Base-List.html">Base.List</a>
30
+
31
+
<a href="Ocamlary-CanonicalTest-Base-List.html">
32
+
Ocamlary.CanonicalTest.Base.List
33
+
</a>
31
34
</span>
32
35
</code>
33
36
</div>
···
36
39
<div class="spec module anchored" id="module-L">
37
40
<a href="#module-L" class="anchor"></a>
38
41
<code><span><span class="keyword">module</span> L</span>
39
-
<span> = <a href="Ocamlary-CanonicalTest-Base-List.html">Base.List</a>
42
+
<span> =
43
+
<a href="Ocamlary-CanonicalTest-Base-List.html">
44
+
Ocamlary.CanonicalTest.Base.List
45
+
</a>
40
46
</span>
41
47
</code>
42
48
</div>
···
63
69
<a href="#val-bar" class="anchor"></a>
64
70
<code>
65
71
<span><span class="keyword">val</span> bar :
72
+
66
73
<span>
67
74
<span><span class="type-var">'a</span>
68
-
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">Base.List.t
75
+
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">
76
+
Ocamlary.CanonicalTest.Base.List.t
69
77
</a>
70
78
</span> <span class="arrow">-></span>
71
-
</span>
79
+
</span>
80
+
72
81
<span><span class="type-var">'a</span>
73
-
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">Base.List.t
82
+
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">
83
+
Ocamlary.CanonicalTest.Base.List.t
74
84
</a>
75
85
</span>
76
86
</span>
···
84
94
<span><span class="keyword">val</span> baz :
85
95
<span>
86
96
<span><span class="type-var">'a</span>
87
-
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">Base.List.t
97
+
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">
98
+
Ocamlary.CanonicalTest.Base.List.t
88
99
</a>
89
100
</span> <span class="arrow">-></span>
90
101
</span> unit
+11
-5
odoc/test/generators/html/Ocamlary-CanonicalTest-List_modif.html
+11
-5
odoc/test/generators/html/Ocamlary-CanonicalTest-List_modif.html
···
24
24
<code><span><span class="keyword">type</span> <span>'c t</span></span>
25
25
<span> =
26
26
<span><span class="type-var">'c</span>
27
-
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">Base.List.t
27
+
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">
28
+
Ocamlary.CanonicalTest.Base.List.t
28
29
</a>
29
30
</span>
30
31
</span>
···
36
37
<a href="#val-id" class="anchor"></a>
37
38
<code>
38
39
<span><span class="keyword">val</span> id :
40
+
39
41
<span>
40
-
<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>
41
-
<span class="arrow">-></span>
42
-
</span>
43
-
<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>
42
+
<span><span class="type-var">'a</span>
43
+
<a href="#type-t">Ocamlary.CanonicalTest.List_modif.t</a>
44
+
</span> <span class="arrow">-></span>
45
+
</span>
46
+
47
+
<span><span class="type-var">'a</span>
48
+
<a href="#type-t">Ocamlary.CanonicalTest.List_modif.t</a>
49
+
</span>
44
50
</span>
45
51
</code>
46
52
</div>
+9
-5
odoc/test/generators/html/Ocamlary-CanonicalTest.html
+9
-5
odoc/test/generators/html/Ocamlary-CanonicalTest.html
···
49
49
<span><span class="keyword">module</span>
50
50
<a href="Ocamlary-CanonicalTest-List_modif.html">List_modif</a>
51
51
</span>
52
-
<span> : <span class="keyword">module</span>
53
-
<span class="keyword">type</span> <span class="keyword">of</span>
54
-
<a href="Ocamlary-CanonicalTest-Base-List.html">Base.List</a>
55
-
<span class="keyword">with</span>
52
+
<span> :
53
+
54
+
<span class="keyword">module</span> <span class="keyword">type</span>
55
+
<span class="keyword">of</span>
56
+
<a href="Ocamlary-CanonicalTest-Base-List.html">Base.List</a>
57
+
58
+
<span class="keyword">with</span>
56
59
<span><span class="keyword">type</span>
57
60
<span>'c <a href="Ocamlary-CanonicalTest-Base-List.html#type-t">t</a>
58
61
</span> =
59
62
<span><span class="type-var">'c</span>
60
-
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">Base.List.t
63
+
<a href="Ocamlary-CanonicalTest-Base-List.html#type-t">
64
+
Ocamlary.CanonicalTest.Base.List.t
61
65
</a>
62
66
</span>
63
67
</span>
+1
-1
odoc/test/generators/html/Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html
+2
-1
odoc/test/generators/html/Ocamlary-CollectionModule-InnerModuleA.html
+2
-1
odoc/test/generators/html/Ocamlary-CollectionModule-InnerModuleA.html
···
24
24
<a href="#type-t" class="anchor"></a>
25
25
<code><span><span class="keyword">type</span> t</span>
26
26
<span> =
27
-
<a href="Ocamlary-CollectionModule.html#type-collection">collection
27
+
<a href="Ocamlary-CollectionModule.html#type-collection">
28
+
Ocamlary.CollectionModule.collection
28
29
</a>
29
30
</span>
30
31
</code>
+3
-2
odoc/test/generators/html/Ocamlary-CollectionModule.html
+3
-2
odoc/test/generators/html/Ocamlary-CollectionModule.html
···
54
54
<span><span class="keyword">module</span>
55
55
<span class="keyword">type</span> InnerModuleTypeA
56
56
</span>
57
-
<span> =
57
+
<span> =
58
+
58
59
<a
59
60
href="Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html"
60
-
>InnerModuleA.InnerModuleTypeA'
61
+
>Ocamlary.CollectionModule.InnerModuleA.InnerModuleTypeA'
61
62
</a>
62
63
</span>
63
64
</code>
+3
-1
odoc/test/generators/html/Ocamlary-Dep1-X.html
+3
-1
odoc/test/generators/html/Ocamlary-Dep1-X.html
···
23
23
<code>
24
24
<span><span class="keyword">module</span>
25
25
<a href="Ocamlary-Dep1-X-Y.html">Y</a>
26
-
</span><span> : <a href="Ocamlary-Dep1-module-type-S.html">S</a></span>
26
+
</span>
27
+
<span> : <a href="Ocamlary-Dep1-module-type-S.html">Ocamlary.Dep1.S</a>
28
+
</span>
27
29
</code>
28
30
</div>
29
31
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep2-argument-1-Arg-X.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep2-argument-1-Arg-X.html
···
23
23
<a href="#module-Y" class="anchor"></a>
24
24
<code><span><span class="keyword">module</span> Y</span>
25
25
<span> :
26
-
<a href="Ocamlary-Dep2-argument-1-Arg.html#module-type-S">S</a>
26
+
<a href="Ocamlary-Dep2-argument-1-Arg.html#module-type-S">Arg.S</a>
27
27
</span>
28
28
</code>
29
29
</div>
+3
-1
odoc/test/generators/html/Ocamlary-Dep4-module-type-S.html
+3
-1
odoc/test/generators/html/Ocamlary-Dep4-module-type-S.html
···
23
23
<code>
24
24
<span><span class="keyword">module</span>
25
25
<a href="Ocamlary-Dep4-module-type-S-X.html">X</a>
26
-
</span><span> : <a href="Ocamlary-Dep4-module-type-T.html">T</a></span>
26
+
</span>
27
+
<span> : <a href="Ocamlary-Dep4-module-type-T.html">Ocamlary.Dep4.T</a>
28
+
</span>
27
29
</code>
28
30
</div>
29
31
</div>
+3
-1
odoc/test/generators/html/Ocamlary-Dep4.html
+3
-1
odoc/test/generators/html/Ocamlary-Dep4.html
···
50
50
<code>
51
51
<span><span class="keyword">module</span>
52
52
<a href="Ocamlary-Dep4-X.html">X</a>
53
-
</span><span> : <a href="Ocamlary-Dep4-module-type-T.html">T</a></span>
53
+
</span>
54
+
<span> : <a href="Ocamlary-Dep4-module-type-T.html">Ocamlary.Dep4.T</a>
55
+
</span>
54
56
</code>
55
57
</div>
56
58
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep5-Z.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep5-Z.html
···
31
31
<div class="spec module anchored" id="module-Y">
32
32
<a href="#module-Y" class="anchor"></a>
33
33
<code><span><span class="keyword">module</span> Y</span>
34
-
<span> = <a href="Ocamlary-Dep3.html">Dep3</a></span>
34
+
<span> = <a href="Ocamlary-Dep3.html">Ocamlary.Dep3</a></span>
35
35
</code>
36
36
</div>
37
37
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep5-argument-1-Arg-module-type-S.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep5-argument-1-Arg-module-type-S.html
···
23
23
<a href="#module-X" class="anchor"></a>
24
24
<code><span><span class="keyword">module</span> X</span>
25
25
<span> :
26
-
<a href="Ocamlary-Dep5-argument-1-Arg.html#module-type-T">T</a>
26
+
<a href="Ocamlary-Dep5-argument-1-Arg.html#module-type-T">Arg.T</a>
27
27
</span>
28
28
</code>
29
29
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep5-argument-1-Arg.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep5-argument-1-Arg.html
···
45
45
<div class="spec module anchored" id="module-X">
46
46
<a href="#module-X" class="anchor"></a>
47
47
<code><span><span class="keyword">module</span> X</span>
48
-
<span> : <a href="#module-type-T">T</a></span>
48
+
<span> : <a href="#module-type-T">Arg.T</a></span>
49
49
</code>
50
50
</div>
51
51
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep5.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep5.html
···
49
49
<span class="keyword">with</span>
50
50
<span><span class="keyword">module</span>
51
51
<a href="Ocamlary-Dep5-argument-1-Arg-module-type-S-Y.html">Y</a>
52
-
= <a href="Ocamlary-Dep3.html">Dep3</a>
52
+
= <a href="Ocamlary-Dep3.html">Ocamlary.Dep3</a>
53
53
</span>
54
54
</span>
55
55
</code>
+7
-2
odoc/test/generators/html/Ocamlary-Dep6-X.html
+7
-2
odoc/test/generators/html/Ocamlary-Dep6-X.html
···
23
23
<code>
24
24
<span><span class="keyword">module</span>
25
25
<span class="keyword">type</span> R
26
-
</span><span> = <a href="Ocamlary-Dep6-module-type-S.html">S</a></span>
26
+
</span>
27
+
<span> = <a href="Ocamlary-Dep6-module-type-S.html">Ocamlary.Dep6.S</a>
28
+
</span>
27
29
</code>
28
30
</div>
29
31
</div>
···
33
35
<code>
34
36
<span><span class="keyword">module</span>
35
37
<a href="Ocamlary-Dep6-X-Y.html">Y</a>
36
-
</span><span> : <a href="Ocamlary-Dep6-module-type-S.html">R</a></span>
38
+
</span>
39
+
<span> :
40
+
<a href="Ocamlary-Dep6-module-type-S.html">Ocamlary.Dep6.X.R</a>
41
+
</span>
37
42
</code>
38
43
</div>
39
44
</div>
+3
-1
odoc/test/generators/html/Ocamlary-Dep6-module-type-T.html
+3
-1
odoc/test/generators/html/Ocamlary-Dep6-module-type-T.html
···
23
23
<code>
24
24
<span><span class="keyword">module</span>
25
25
<span class="keyword">type</span> R
26
-
</span><span> = <a href="Ocamlary-Dep6-module-type-S.html">S</a></span>
26
+
</span>
27
+
<span> = <a href="Ocamlary-Dep6-module-type-S.html">Ocamlary.Dep6.S</a>
28
+
</span>
27
29
</code>
28
30
</div>
29
31
</div>
+3
-1
odoc/test/generators/html/Ocamlary-Dep6.html
+3
-1
odoc/test/generators/html/Ocamlary-Dep6.html
···
50
50
<code>
51
51
<span><span class="keyword">module</span>
52
52
<a href="Ocamlary-Dep6-X.html">X</a>
53
-
</span><span> : <a href="Ocamlary-Dep6-module-type-T.html">T</a></span>
53
+
</span>
54
+
<span> : <a href="Ocamlary-Dep6-module-type-T.html">Ocamlary.Dep6.T</a>
55
+
</span>
54
56
</code>
55
57
</div>
56
58
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep7-M.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep7-M.html
···
35
35
<a href="#module-Y" class="anchor"></a>
36
36
<code><span><span class="keyword">module</span> Y</span>
37
37
<span> :
38
-
<a href="Ocamlary-Dep7-argument-1-Arg.html#module-type-S">R</a>
38
+
<a href="Ocamlary-Dep7-argument-1-Arg.html#module-type-S">M.R</a>
39
39
</span>
40
40
</code>
41
41
</div>
+2
-2
odoc/test/generators/html/Ocamlary-Dep7-argument-1-Arg-X.html
+2
-2
odoc/test/generators/html/Ocamlary-Dep7-argument-1-Arg-X.html
···
26
26
<span class="keyword">type</span> R
27
27
</span>
28
28
<span> =
29
-
<a href="Ocamlary-Dep7-argument-1-Arg.html#module-type-S">S</a>
29
+
<a href="Ocamlary-Dep7-argument-1-Arg.html#module-type-S">Arg.S</a>
30
30
</span>
31
31
</code>
32
32
</div>
···
36
36
<a href="#module-Y" class="anchor"></a>
37
37
<code><span><span class="keyword">module</span> Y</span>
38
38
<span> :
39
-
<a href="Ocamlary-Dep7-argument-1-Arg.html#module-type-S">R</a>
39
+
<a href="Ocamlary-Dep7-argument-1-Arg.html#module-type-S">Arg.X.R</a>
40
40
</span>
41
41
</code>
42
42
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Dep7-argument-1-Arg-module-type-T.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep7-argument-1-Arg-module-type-T.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep7-argument-1-Arg.html
+1
-1
odoc/test/generators/html/Ocamlary-Dep7-argument-1-Arg.html
+1
-1
odoc/test/generators/html/Ocamlary-DoubleInclude3.html
+1
-1
odoc/test/generators/html/Ocamlary-DoubleInclude3.html
···
23
23
<span><span class="keyword">include</span>
24
24
<span class="keyword">module</span> <span class="keyword">type</span>
25
25
<span class="keyword">of</span>
26
-
<a href="Ocamlary-DoubleInclude1.html">DoubleInclude1</a>
26
+
<a href="Ocamlary-DoubleInclude1.html">Ocamlary.DoubleInclude1</a>
27
27
</span>
28
28
</code>
29
29
</summary>
+2
-1
odoc/test/generators/html/Ocamlary-ExtMod.html
+2
-1
odoc/test/generators/html/Ocamlary-ExtMod.html
···
29
29
id="extension-decl-Leisureforce">
30
30
<a href="#extension-decl-Leisureforce" class="anchor"></a>
31
31
<code>
32
-
<span><span class="keyword">type</span> <a href="#type-t">t</a> +=
32
+
<span><span class="keyword">type</span>
33
+
<a href="#type-t">Ocamlary.ExtMod.t</a> +=
33
34
</span>
34
35
</code>
35
36
<ol>
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection.html
+1
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection.html
+2
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf.html
+2
-1
odoc/test/generators/html/Ocamlary-FunctorTypeOf.html
···
36
36
</span>
37
37
<span> : <span class="keyword">module</span>
38
38
<span class="keyword">type</span> <span class="keyword">of</span>
39
-
<a href="Ocamlary-CollectionModule.html">CollectionModule</a>
39
+
40
+
<a href="Ocamlary-CollectionModule.html">Ocamlary.CollectionModule</a>
40
41
</span>
41
42
</code>
42
43
</div>
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C.html
+1
-1
odoc/test/generators/html/Ocamlary-Recollection-argument-1-C.html
+2
-1
odoc/test/generators/html/Ocamlary-Recollection.html
+2
-1
odoc/test/generators/html/Ocamlary-Recollection.html
···
31
31
<a href="#argument-1-C" class="anchor"></a>
32
32
<code><span><span class="keyword">module</span> </span>
33
33
<span><a href="Ocamlary-Recollection-argument-1-C.html">C</a></span>
34
-
<span> : <a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
34
+
<span> :
35
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION</a>
35
36
</span>
36
37
</code>
37
38
</div>
+1
-1
odoc/test/generators/html/Ocamlary-With3.html
+1
-1
odoc/test/generators/html/Ocamlary-With3.html
···
20
20
<div class="spec module anchored" id="module-M">
21
21
<a href="#module-M" class="anchor"></a>
22
22
<code><span><span class="keyword">module</span> M</span>
23
-
<span> = <a href="Ocamlary-With2.html">With2</a></span>
23
+
<span> = <a href="Ocamlary-With2.html">Ocamlary.With2</a></span>
24
24
</code>
25
25
</div>
26
26
</div>
+3
-1
odoc/test/generators/html/Ocamlary-With4.html
+3
-1
odoc/test/generators/html/Ocamlary-With4.html
···
23
23
<span><span class="keyword">module</span>
24
24
<a href="Ocamlary-With4-N.html">N</a>
25
25
</span>
26
-
<span> : <a href="Ocamlary-With2.html#module-type-S">With2.S</a></span>
26
+
<span> :
27
+
<a href="Ocamlary-With2.html#module-type-S">Ocamlary.With2.S</a>
28
+
</span>
27
29
</code>
28
30
</div>
29
31
</div>
+3
-1
odoc/test/generators/html/Ocamlary-With5.html
+3
-1
odoc/test/generators/html/Ocamlary-With5.html
···
37
37
<span><span class="keyword">module</span>
38
38
<a href="Ocamlary-With5-N.html">N</a>
39
39
</span>
40
-
<span> : <a href="Ocamlary-With5-module-type-S.html">S</a></span>
40
+
<span> :
41
+
<a href="Ocamlary-With5-module-type-S.html">Ocamlary.With5.S</a>
42
+
</span>
41
43
</code>
42
44
</div>
43
45
</div>
+1
-1
odoc/test/generators/html/Ocamlary-With6-module-type-T-M.html
+1
-1
odoc/test/generators/html/Ocamlary-With6-module-type-T-M.html
···
31
31
<div class="spec module anchored" id="module-N">
32
32
<a href="#module-N" class="anchor"></a>
33
33
<code><span><span class="keyword">module</span> N</span>
34
-
<span> : <a href="#module-type-S">S</a></span>
34
+
<span> : <a href="#module-type-S">M.S</a></span>
35
35
</code>
36
36
</div>
37
37
</div>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA.html
···
24
24
<a href="#type-t" class="anchor"></a>
25
25
<code><span><span class="keyword">type</span> t</span>
26
26
<span> =
27
-
<a href="Ocamlary-module-type-A-Q.html#type-collection">collection</a>
27
+
<a href="Ocamlary-module-type-A-Q.html#type-collection">Q.collection
28
+
</a>
28
29
</span>
29
30
</code>
30
31
</div>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-A-Q.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-A.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-A.html
···
29
29
<span><span class="keyword">module</span>
30
30
<a href="Ocamlary-module-type-A-Q.html">Q</a>
31
31
</span>
32
-
<span> : <a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
32
+
<span> :
33
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION</a>
33
34
</span>
34
35
</code>
35
36
</div>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA.html
···
24
24
<a href="#type-t" class="anchor"></a>
25
25
<code><span><span class="keyword">type</span> t</span>
26
26
<span> =
27
-
<a href="Ocamlary-module-type-B-Q.html#type-collection">collection</a>
27
+
<a href="Ocamlary-module-type-B-Q.html#type-collection">Q.collection
28
+
</a>
28
29
</span>
29
30
</code>
30
31
</div>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-B-Q.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-B.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-B.html
···
29
29
<span><span class="keyword">module</span>
30
30
<a href="Ocamlary-module-type-B-Q.html">Q</a>
31
31
</span>
32
-
<span> : <a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
32
+
<span> :
33
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION</a>
33
34
</span>
34
35
</code>
35
36
</div>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA.html
···
24
24
<a href="#type-t" class="anchor"></a>
25
25
<code><span><span class="keyword">type</span> t</span>
26
26
<span> =
27
-
<a href="Ocamlary-module-type-C-Q.html#type-collection">collection</a>
27
+
<a href="Ocamlary-module-type-C-Q.html#type-collection">Q.collection
28
+
</a>
28
29
</span>
29
30
</code>
30
31
</div>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-C-Q.html
+4
-3
odoc/test/generators/html/Ocamlary-module-type-C.html
+4
-3
odoc/test/generators/html/Ocamlary-module-type-C.html
···
29
29
<summary class="spec include">
30
30
<code>
31
31
<span><span class="keyword">include</span>
32
-
<a href="Ocamlary-module-type-A.html">A</a>
32
+
<a href="Ocamlary-module-type-A.html">Ocamlary.A</a>
33
33
</span>
34
34
</code>
35
35
</summary>
···
47
47
<a href="Ocamlary-module-type-C-Q.html">Q</a>
48
48
</span>
49
49
<span> :
50
-
<a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
50
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION
51
+
</a>
51
52
</span>
52
53
</code>
53
54
</div>
···
62
63
<summary class="spec include">
63
64
<code>
64
65
<span><span class="keyword">include</span>
65
-
<a href="Ocamlary-module-type-B.html">B</a>
66
+
<a href="Ocamlary-module-type-B.html">Ocamlary.B</a>
66
67
<span class="keyword">with</span>
67
68
<span><span class="keyword">type</span>
68
69
<a href="Ocamlary-module-type-B.html#type-t">t</a> :=
+1
-1
odoc/test/generators/html/Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-IncludeModuleType.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-IncludeModuleType.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA.html
···
24
24
<a href="#type-t" class="anchor"></a>
25
25
<code><span><span class="keyword">type</span> t</span>
26
26
<span> =
27
-
<a href="Ocamlary-module-type-MMM-C.html#type-collection">collection
27
+
<a href="Ocamlary-module-type-MMM-C.html#type-collection">C.collection
28
28
</a>
29
29
</span>
30
30
</code>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-MMM-C.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-MMM.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-MMM.html
···
23
23
<span><span class="keyword">module</span>
24
24
<a href="Ocamlary-module-type-MMM-C.html">C</a>
25
25
</span>
26
-
<span> : <a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
26
+
<span> :
27
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION</a>
27
28
</span>
28
29
</code>
29
30
</div>
+2
-1
odoc/test/generators/html/Ocamlary-module-type-RECOLLECTION.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-RECOLLECTION.html
···
21
21
<a href="#module-C" class="anchor"></a>
22
22
<code><span><span class="keyword">module</span> C</span>
23
23
<span> =
24
-
<a href="Ocamlary-Recollection.html">Recollection(CollectionModule)
24
+
<a href="Ocamlary-Recollection.html">
25
+
Ocamlary.Recollection(Ocamlary.CollectionModule)
25
26
</a>
26
27
</span>
27
28
</code>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html
+2
-2
odoc/test/generators/html/Ocamlary-module-type-RecollectionModule.html
+2
-2
odoc/test/generators/html/Ocamlary-module-type-RecollectionModule.html
···
32
32
<span> =
33
33
<span>
34
34
<a href="Ocamlary-CollectionModule.html#type-element">
35
-
CollectionModule.element
35
+
Ocamlary.CollectionModule.element
36
36
</a> list
37
37
</span>
38
38
</span>
···
45
45
<code><span><span class="keyword">type</span> element</span>
46
46
<span> =
47
47
<a href="Ocamlary-CollectionModule.html#type-collection">
48
-
CollectionModule.collection
48
+
Ocamlary.CollectionModule.collection
49
49
</a>
50
50
</span>
51
51
</code>
+2
-2
odoc/test/generators/html/Ocamlary-module-type-TypeExtPruned.html
+2
-2
odoc/test/generators/html/Ocamlary-module-type-TypeExtPruned.html
···
21
21
<a href="#extension-decl-C" class="anchor"></a>
22
22
<code>
23
23
<span><span class="keyword">type</span>
24
-
<a href="Ocamlary.html#type-new_t">new_t</a> +=
24
+
<a href="Ocamlary.html#type-new_t">Ocamlary.new_t</a> +=
25
25
</span>
26
26
</code>
27
27
<ol>
···
38
38
<a href="#val-f" class="anchor"></a>
39
39
<code>
40
40
<span><span class="keyword">val</span> f :
41
-
<span><a href="Ocamlary.html#type-new_t">new_t</a>
41
+
<span><a href="Ocamlary.html#type-new_t">Ocamlary.new_t</a>
42
42
<span class="arrow">-></span>
43
43
</span> unit
44
44
</span>
+1
-1
odoc/test/generators/html/Ocamlary-module-type-With11.html
+1
-1
odoc/test/generators/html/Ocamlary-module-type-With11.html
···
20
20
<div class="spec module anchored" id="module-M">
21
21
<a href="#module-M" class="anchor"></a>
22
22
<code><span><span class="keyword">module</span> M</span>
23
-
<span> = <a href="Ocamlary-With9.html">With9</a></span>
23
+
<span> = <a href="Ocamlary-With9.html">Ocamlary.With9</a></span>
24
24
</code>
25
25
</div>
26
26
</div>
+2
-1
odoc/test/generators/html/Ocamlary-module-type-With8-M-N.html
+2
-1
odoc/test/generators/html/Ocamlary-module-type-With8-M-N.html
···
21
21
<div class="spec type anchored" id="type-t">
22
22
<a href="#type-t" class="anchor"></a>
23
23
<code><span><span class="keyword">type</span> t</span>
24
-
<span> = <a href="Ocamlary-With5-N.html#type-t">With5.N.t</a></span>
24
+
<span> = <a href="Ocamlary-With5-N.html#type-t">Ocamlary.With5.N.t</a>
25
+
</span>
25
26
</code>
26
27
</div>
27
28
</div>
+13
-9
odoc/test/generators/html/Ocamlary-module-type-With8-M.html
+13
-9
odoc/test/generators/html/Ocamlary-module-type-With8-M.html
···
24
24
<span><span class="keyword">module</span>
25
25
<span class="keyword">type</span> S
26
26
</span>
27
-
<span> = <a href="Ocamlary-With5-module-type-S.html">With5.S</a></span>
27
+
<span> =
28
+
<a href="Ocamlary-With5-module-type-S.html">Ocamlary.With5.S</a>
29
+
</span>
28
30
</code>
29
31
</div>
30
32
</div>
···
35
37
<span><span class="keyword">module</span>
36
38
<a href="Ocamlary-module-type-With8-M-N.html">N</a>
37
39
</span>
38
-
<span> : <span class="keyword">module</span>
39
-
<span class="keyword">type</span> <span class="keyword">of</span>
40
-
<span class="keyword">struct</span>
41
-
<span class="keyword">include</span>
42
-
<a href="Ocamlary-With5-N.html">With5.N</a>
43
-
<span class="keyword">end</span> <span class="keyword">with</span>
44
-
40
+
<span> :
41
+
42
+
<span class="keyword">module</span> <span class="keyword">type</span>
43
+
<span class="keyword">of</span> <span class="keyword">struct</span>
44
+
<span class="keyword">include</span>
45
+
<a href="Ocamlary-With5-N.html">Ocamlary.With5.N</a>
46
+
<span class="keyword">end</span>
47
+
48
+
<span class="keyword">with</span>
45
49
<span><span class="keyword">type</span>
46
50
<a href="Ocamlary-With5-N.html#type-t">t</a> =
47
-
<a href="Ocamlary-With5-N.html#type-t">With5.N.t</a>
51
+
<a href="Ocamlary-With5-N.html#type-t">Ocamlary.With5.N.t</a>
48
52
</span>
49
53
</span>
50
54
</code>
+10
-8
odoc/test/generators/html/Ocamlary-module-type-With8.html
+10
-8
odoc/test/generators/html/Ocamlary-module-type-With8.html
···
23
23
<span><span class="keyword">module</span>
24
24
<a href="Ocamlary-module-type-With8-M.html">M</a>
25
25
</span>
26
-
<span> : <span class="keyword">module</span>
27
-
<span class="keyword">type</span> <span class="keyword">of</span>
28
-
<span class="keyword">struct</span>
29
-
<span class="keyword">include</span>
30
-
<a href="Ocamlary-With5.html">With5</a>
31
-
<span class="keyword">end</span> <span class="keyword">with</span>
32
-
26
+
<span> :
27
+
28
+
<span class="keyword">module</span> <span class="keyword">type</span>
29
+
<span class="keyword">of</span> <span class="keyword">struct</span>
30
+
<span class="keyword">include</span>
31
+
<a href="Ocamlary-With5.html">Ocamlary.With5</a>
32
+
<span class="keyword">end</span>
33
+
34
+
<span class="keyword">with</span>
33
35
<span><span class="keyword">type</span>
34
36
<a href="Ocamlary-With5-N.html#type-t">N.t</a> =
35
-
<a href="Ocamlary-With5-N.html#type-t">With5.N.t</a>
37
+
<a href="Ocamlary-With5-N.html#type-t">Ocamlary.With5.N.t</a>
36
38
</span>
37
39
</span>
38
40
</code>
+157
-101
odoc/test/generators/html/Ocamlary.html
+157
-101
odoc/test/generators/html/Ocamlary.html
···
150
150
<div class="spec module anchored" id="module-EmptyAlias">
151
151
<a href="#module-EmptyAlias" class="anchor"></a>
152
152
<code><span><span class="keyword">module</span> EmptyAlias</span>
153
-
<span> = <a href="Ocamlary-Empty.html">Empty</a></span>
153
+
<span> = <a href="Ocamlary-Empty.html">Ocamlary.Empty</a></span>
154
154
</code>
155
155
</div>
156
156
<div class="spec-doc"><p>A plain module alias of <code>Empty</code></p>
···
178
178
<span><span class="keyword">module</span>
179
179
<span class="keyword">type</span> EmptySigAlias
180
180
</span>
181
-
<span> = <a href="Ocamlary-module-type-EmptySig.html">EmptySig</a>
181
+
<span> =
182
+
<a href="Ocamlary-module-type-EmptySig.html">Ocamlary.EmptySig</a>
182
183
</span>
183
184
</code>
184
185
</div>
···
192
193
<span><span class="keyword">module</span>
193
194
<a href="Ocamlary-ModuleWithSignature.html">ModuleWithSignature</a>
194
195
</span>
195
-
<span> : <a href="Ocamlary-module-type-EmptySig.html">EmptySig</a>
196
+
<span> :
197
+
<a href="Ocamlary-module-type-EmptySig.html">Ocamlary.EmptySig</a>
196
198
</span>
197
199
</code>
198
200
</div>
···
212
214
ModuleWithSignatureAlias
213
215
</a>
214
216
</span>
215
-
<span> : <a href="Ocamlary-module-type-EmptySig.html">EmptySigAlias</a>
217
+
<span> :
218
+
<a href="Ocamlary-module-type-EmptySig.html">Ocamlary.EmptySigAlias
219
+
</a>
216
220
</span>
217
221
</code>
218
222
</div>
···
417
421
<a href="#val-fun_fun_fun" class="anchor"></a>
418
422
<code>
419
423
<span><span class="keyword">val</span> fun_fun_fun :
424
+
420
425
<span>
421
426
<span>(
422
427
<span><span>(int, int)</span>
423
-
<a href="#type-a_function">a_function</a>
428
+
<a href="#type-a_function">Ocamlary.a_function</a>
424
429
</span>,
425
430
<span><span>(unit, unit)</span>
426
-
<a href="#type-a_function">a_function</a>
431
+
<a href="#type-a_function">Ocamlary.a_function</a>
427
432
</span>)
428
-
</span> <a href="#type-a_function">a_function</a>
433
+
</span>
434
+
435
+
<a href="#type-a_function">Ocamlary.a_function</a>
429
436
</span>
430
437
</span>
431
438
</code>
···
679
686
</span>
680
687
<span> = <span class="keyword">module</span>
681
688
<span class="keyword">type</span> <span class="keyword">of</span>
682
-
<a href="Ocamlary-CollectionModule.html">CollectionModule</a>
689
+
690
+
<a href="Ocamlary-CollectionModule.html">Ocamlary.CollectionModule</a>
683
691
</span>
684
692
</code>
685
693
</div><div class="spec-doc"><p>module type of</p></div>
···
694
702
<span>
695
703
696
704
(<a href="Ocamlary-Recollection-argument-1-C.html">C</a> :
697
-
<a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>)
698
-
:
699
-
700
-
<a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
701
-
702
-
<span class="keyword">with</span>
705
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION</a>
706
+
) :
707
+
708
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION</a>
709
+
710
+
<span class="keyword">with</span>
703
711
<span><span class="keyword">type</span>
704
712
<a href="Ocamlary-module-type-COLLECTION.html#type-collection">
705
713
collection
···
748
756
<span class="keyword">type</span>
749
757
<a href="Ocamlary-module-type-RECOLLECTION.html">RECOLLECTION</a>
750
758
</span>
751
-
<span> = <a href="Ocamlary-module-type-MMM.html">MMM</a>
759
+
<span> =
760
+
761
+
<a href="Ocamlary-module-type-MMM.html">Ocamlary.MMM</a>
752
762
<span class="keyword">with</span>
753
763
<span><span class="keyword">module</span>
754
764
<a href="Ocamlary-module-type-MMM-C.html">C</a> =
755
-
<a href="Ocamlary-Recollection.html">Recollection(CollectionModule)
765
+
<a href="Ocamlary-Recollection.html">
766
+
Ocamlary.Recollection(Ocamlary.CollectionModule)
756
767
</a>
757
768
</span>
758
769
</span>
···
833
844
<a href="Ocamlary-FunctorTypeOf-argument-1-Collection.html">Collection
834
845
</a> : <span class="keyword">module</span>
835
846
<span class="keyword">type</span> <span class="keyword">of</span>
836
-
<a href="Ocamlary-CollectionModule.html">CollectionModule</a>
847
+
848
+
<a href="Ocamlary-CollectionModule.html">Ocamlary.CollectionModule</a>
837
849
) :
838
850
839
851
<span class="keyword">sig</span> ... <span class="keyword">end</span>
···
882
894
<summary class="spec include">
883
895
<code>
884
896
<span><span class="keyword">include</span>
885
-
<a href="Ocamlary-module-type-ToInclude.html">ToInclude</a>
897
+
<a href="Ocamlary-module-type-ToInclude.html">Ocamlary.ToInclude</a>
886
898
</span>
887
899
</code>
888
900
</summary>
···
1099
1111
<code><span>| </span>
1100
1112
<span><span class="constructor">Tag</span> :
1101
1113
<span><span>(unit, unit)</span>
1102
-
<a href="#type-full_gadt">full_gadt</a>
1114
+
<a href="#type-full_gadt">Ocamlary.full_gadt</a>
1103
1115
</span>
1104
1116
</span>
1105
1117
</code>
···
1111
1123
<span class="type-var">'a</span>
1112
1124
<span class="arrow">-></span>
1113
1125
<span><span>(<span class="type-var">'a</span>, unit)</span>
1114
-
<a href="#type-full_gadt">full_gadt</a>
1126
+
<a href="#type-full_gadt">Ocamlary.full_gadt</a>
1115
1127
</span>
1116
1128
</span>
1117
1129
</code>
···
1123
1135
<span class="type-var">'a</span>
1124
1136
<span class="arrow">-></span>
1125
1137
<span><span>(unit, <span class="type-var">'a</span>)</span>
1126
-
<a href="#type-full_gadt">full_gadt</a>
1138
+
<a href="#type-full_gadt">Ocamlary.full_gadt</a>
1127
1139
</span>
1128
1140
</span>
1129
1141
</code>
···
1135
1147
<span class="type-var">'a</span> * <span class="type-var">'b</span>
1136
1148
<span class="arrow">-></span>
1137
1149
<span><span>(<span class="type-var">'b</span>, unit)</span>
1138
-
<a href="#type-full_gadt">full_gadt</a>
1150
+
<a href="#type-full_gadt">Ocamlary.full_gadt</a>
1139
1151
</span>
1140
1152
</span>
1141
1153
</code>
···
1159
1171
<code><span>| </span>
1160
1172
<span><span class="constructor">AscribeTag</span> :
1161
1173
<span><span class="type-var">'a</span>
1162
-
<a href="#type-partial_gadt">partial_gadt</a>
1174
+
<a href="#type-partial_gadt">Ocamlary.partial_gadt</a>
1163
1175
</span>
1164
1176
</span>
1165
1177
</code>
···
1170
1182
<span><span class="constructor">OfTag</span>
1171
1183
<span class="keyword">of</span>
1172
1184
<span><span class="type-var">'a</span>
1173
-
<a href="#type-partial_gadt">partial_gadt</a>
1185
+
<a href="#type-partial_gadt">Ocamlary.partial_gadt</a>
1174
1186
</span>
1175
1187
</span>
1176
1188
</code>
···
1186
1198
</span> <span class="type-var">'b</span>)
1187
1199
</span> <span class="arrow">-></span>
1188
1200
<span><span class="type-var">'a</span>
1189
-
<a href="#type-partial_gadt">partial_gadt</a>
1201
+
<a href="#type-partial_gadt">Ocamlary.partial_gadt</a>
1190
1202
</span>
1191
1203
</span>
1192
1204
</code>
···
1202
1214
<div class="spec type anchored" id="type-alias">
1203
1215
<a href="#type-alias" class="anchor"></a>
1204
1216
<code><span><span class="keyword">type</span> alias</span>
1205
-
<span> = <a href="#type-variant">variant</a></span>
1217
+
<span> = <a href="#type-variant">Ocamlary.variant</a></span>
1206
1218
</code>
1207
1219
</div>
1208
1220
<div class="spec-doc"><p>This comment is for <code>alias</code>.</p>
···
1212
1224
<div class="spec type anchored" id="type-tuple">
1213
1225
<a href="#type-tuple" class="anchor"></a>
1214
1226
<code><span><span class="keyword">type</span> tuple</span>
1215
-
<span> =
1216
-
<span>(<a href="#type-alias">alias</a> *
1217
-
<a href="#type-alias">alias</a>)
1218
-
</span> * <a href="#type-alias">alias</a> *
1219
-
<span>(<a href="#type-alias">alias</a> *
1220
-
<a href="#type-alias">alias</a>)
1227
+
<span> =
1228
+
1229
+
<span>(<a href="#type-alias">Ocamlary.alias</a> *
1230
+
<a href="#type-alias">Ocamlary.alias</a>)
1231
+
</span>
1232
+
1233
+
* <a href="#type-alias">Ocamlary.alias</a>
1234
+
1235
+
*
1236
+
<span>(<a href="#type-alias">Ocamlary.alias</a> *
1237
+
<a href="#type-alias">Ocamlary.alias</a>)
1221
1238
</span>
1222
1239
</span>
1223
1240
</code>
···
1229
1246
<div class="spec type anchored" id="type-variant_alias">
1230
1247
<a href="#type-variant_alias" class="anchor"></a>
1231
1248
<code><span><span class="keyword">type</span> variant_alias</span>
1232
-
<span> = <a href="#type-variant">variant</a></span><span> = </span>
1249
+
<span> = <a href="#type-variant">Ocamlary.variant</a></span>
1250
+
<span> = </span>
1233
1251
</code>
1234
1252
<ol>
1235
1253
<li id="type-variant_alias.TagA" class="def variant constructor
···
1272
1290
<div class="spec type anchored" id="type-record_alias">
1273
1291
<a href="#type-record_alias" class="anchor"></a>
1274
1292
<code><span><span class="keyword">type</span> record_alias</span>
1275
-
<span> = <a href="#type-record">record</a></span><span> = </span>
1276
-
<span>{</span>
1293
+
<span> = <a href="#type-record">Ocamlary.record</a></span>
1294
+
<span> = </span><span>{</span>
1277
1295
</code>
1278
1296
<ol>
1279
1297
<li id="type-record_alias.field1" class="def record field anchored">
···
1297
1315
<span> = </span><span>[ </span>
1298
1316
</code>
1299
1317
<ol>
1300
-
<li id="type-poly_variant_union.poly_variant" class="def variant
1301
-
type anchored">
1302
-
<a href="#type-poly_variant_union.poly_variant" class="anchor"></a>
1318
+
<li id="type-poly_variant_union.Ocamlary.poly_variant" class="def
1319
+
variant type anchored">
1320
+
<a href="#type-poly_variant_union.Ocamlary.poly_variant"
1321
+
class="anchor">
1322
+
</a>
1303
1323
<code><span>| </span>
1304
-
<span><a href="#type-poly_variant">poly_variant</a></span>
1324
+
<span><a href="#type-poly_variant">Ocamlary.poly_variant</a></span>
1305
1325
</code>
1306
1326
</li>
1307
1327
<li id="type-poly_variant_union.TagC" class="def variant constructor
···
1396
1416
<span><span class="keyword">type</span>
1397
1417
<span>'a open_poly_variant_alias</span>
1398
1418
</span>
1399
-
<span> =
1419
+
<span> =
1420
+
1400
1421
<span>
1401
1422
<span><span class="type-var">'a</span>
1402
-
<a href="#type-open_poly_variant">open_poly_variant</a>
1403
-
</span> <a href="#type-open_poly_variant2">open_poly_variant2</a>
1423
+
<a href="#type-open_poly_variant">Ocamlary.open_poly_variant</a>
1424
+
</span>
1425
+
<a href="#type-open_poly_variant2">Ocamlary.open_poly_variant2</a>
1404
1426
</span>
1405
1427
</span>
1406
1428
</code>
···
1512
1534
<span>
1513
1535
<span>(<span class="type-var">'a</span>,
1514
1536
<span class="type-var">'b</span>)
1515
-
</span> <a href="#type-full_gadt">full_gadt</a>
1537
+
</span> <a href="#type-full_gadt">Ocamlary.full_gadt</a>
1516
1538
</span>
1517
1539
</span><span> = </span>
1518
1540
</code>
···
1522
1544
<code><span>| </span>
1523
1545
<span><span class="constructor">Tag</span> :
1524
1546
<span><span>(unit, unit)</span>
1525
-
<a href="#type-full_gadt_alias">full_gadt_alias</a>
1547
+
<a href="#type-full_gadt_alias">Ocamlary.full_gadt_alias</a>
1526
1548
</span>
1527
1549
</span>
1528
1550
</code>
···
1534
1556
<span class="type-var">'a</span>
1535
1557
<span class="arrow">-></span>
1536
1558
<span><span>(<span class="type-var">'a</span>, unit)</span>
1537
-
<a href="#type-full_gadt_alias">full_gadt_alias</a>
1559
+
<a href="#type-full_gadt_alias">Ocamlary.full_gadt_alias</a>
1538
1560
</span>
1539
1561
</span>
1540
1562
</code>
···
1546
1568
<span class="type-var">'a</span>
1547
1569
<span class="arrow">-></span>
1548
1570
<span><span>(unit, <span class="type-var">'a</span>)</span>
1549
-
<a href="#type-full_gadt_alias">full_gadt_alias</a>
1571
+
<a href="#type-full_gadt_alias">Ocamlary.full_gadt_alias</a>
1550
1572
</span>
1551
1573
</span>
1552
1574
</code>
···
1558
1580
<span class="type-var">'a</span> * <span class="type-var">'b</span>
1559
1581
<span class="arrow">-></span>
1560
1582
<span><span>(<span class="type-var">'b</span>, unit)</span>
1561
-
<a href="#type-full_gadt_alias">full_gadt_alias</a>
1583
+
<a href="#type-full_gadt_alias">Ocamlary.full_gadt_alias</a>
1562
1584
</span>
1563
1585
</span>
1564
1586
</code>
···
1578
1600
</span>
1579
1601
<span> =
1580
1602
<span><span class="type-var">'a</span>
1581
-
<a href="#type-partial_gadt">partial_gadt</a>
1603
+
<a href="#type-partial_gadt">Ocamlary.partial_gadt</a>
1582
1604
</span>
1583
1605
</span><span> = </span>
1584
1606
</code>
···
1589
1611
<code><span>| </span>
1590
1612
<span><span class="constructor">AscribeTag</span> :
1591
1613
<span><span class="type-var">'a</span>
1592
-
<a href="#type-partial_gadt_alias">partial_gadt_alias</a>
1614
+
<a href="#type-partial_gadt_alias">Ocamlary.partial_gadt_alias</a>
1593
1615
</span>
1594
1616
</span>
1595
1617
</code>
···
1600
1622
<span><span class="constructor">OfTag</span>
1601
1623
<span class="keyword">of</span>
1602
1624
<span><span class="type-var">'a</span>
1603
-
<a href="#type-partial_gadt_alias">partial_gadt_alias</a>
1625
+
<a href="#type-partial_gadt_alias">Ocamlary.partial_gadt_alias</a>
1604
1626
</span>
1605
1627
</span>
1606
1628
</code>
···
1616
1638
</span> <span class="type-var">'b</span>)
1617
1639
</span> <span class="arrow">-></span>
1618
1640
<span><span class="type-var">'a</span>
1619
-
<a href="#type-partial_gadt_alias">partial_gadt_alias</a>
1641
+
<a href="#type-partial_gadt_alias">Ocamlary.partial_gadt_alias</a>
1620
1642
</span>
1621
1643
</span>
1622
1644
</code>
···
1659
1681
<code><span>| </span>
1660
1682
<span><span class="constructor">B_ish</span>
1661
1683
<span class="keyword">of</span>
1662
-
<a href="#type-mutual_constr_b">mutual_constr_b</a>
1684
+
<a href="#type-mutual_constr_b">Ocamlary.mutual_constr_b</a>
1663
1685
</span>
1664
1686
</code>
1665
1687
<div class="def-doc"><span class="comment-delim">(*</span>
···
1698
1720
<code><span>| </span>
1699
1721
<span><span class="constructor">A_ish</span>
1700
1722
<span class="keyword">of</span>
1701
-
<a href="#type-mutual_constr_a">mutual_constr_a</a>
1723
+
<a href="#type-mutual_constr_a">Ocamlary.mutual_constr_a</a>
1702
1724
</span>
1703
1725
</code>
1704
1726
<div class="def-doc"><span class="comment-delim">(*</span>
···
1723
1745
<span> =
1724
1746
<span>< f : int ; g :
1725
1747
<span>unit <span class="arrow">-></span></span> unit ;
1726
-
h : <a href="#type-rec_obj">rec_obj</a> >
1748
+
h : <a href="#type-rec_obj">Ocamlary.rec_obj</a> >
1727
1749
</span>
1728
1750
</span>
1729
1751
</code>
···
1794
1816
<div class="spec type extension anchored" id="extension-decl-ExtA">
1795
1817
<a href="#extension-decl-ExtA" class="anchor"></a>
1796
1818
<code>
1797
-
<span><span class="keyword">type</span> <a href="#type-ext">ext</a> +=
1819
+
<span><span class="keyword">type</span>
1820
+
<a href="#type-ext">Ocamlary.ext</a> +=
1798
1821
</span>
1799
1822
</code>
1800
1823
<ol>
···
1810
1833
<div class="spec type extension anchored" id="extension-decl-ExtB">
1811
1834
<a href="#extension-decl-ExtB" class="anchor"></a>
1812
1835
<code>
1813
-
<span><span class="keyword">type</span> <a href="#type-ext">ext</a> +=
1836
+
<span><span class="keyword">type</span>
1837
+
<a href="#type-ext">Ocamlary.ext</a> +=
1814
1838
</span>
1815
1839
</code>
1816
1840
<ol>
···
1826
1850
<div class="spec type extension anchored" id="extension-decl-ExtC">
1827
1851
<a href="#extension-decl-ExtC" class="anchor"></a>
1828
1852
<code>
1829
-
<span><span class="keyword">type</span> <a href="#type-ext">ext</a> +=
1853
+
<span><span class="keyword">type</span>
1854
+
<a href="#type-ext">Ocamlary.ext</a> +=
1830
1855
</span>
1831
1856
</code>
1832
1857
<ol>
···
1842
1867
<a href="#extension-ExtD" class="anchor"></a>
1843
1868
<code><span>| </span>
1844
1869
<span><span class="extension">ExtD</span>
1845
-
<span class="keyword">of</span> <a href="#type-ext">ext</a>
1870
+
<span class="keyword">of</span> <a href="#type-ext">Ocamlary.ext</a>
1846
1871
</span>
1847
1872
</code>
1848
1873
</li>
···
1853
1878
<div class="spec type extension anchored" id="extension-decl-ExtE">
1854
1879
<a href="#extension-decl-ExtE" class="anchor"></a>
1855
1880
<code>
1856
-
<span><span class="keyword">type</span> <a href="#type-ext">ext</a> +=
1881
+
<span><span class="keyword">type</span>
1882
+
<a href="#type-ext">Ocamlary.ext</a> +=
1857
1883
</span>
1858
1884
</code>
1859
1885
<ol>
···
1869
1895
<div class="spec type extension anchored" id="extension-decl-ExtF">
1870
1896
<a href="#extension-decl-ExtF" class="anchor"></a>
1871
1897
<code>
1872
-
<span><span class="keyword">type</span> <a href="#type-ext">ext</a>
1873
-
+= <span class="keyword">private</span>
1898
+
<span><span class="keyword">type</span>
1899
+
<a href="#type-ext">Ocamlary.ext</a> +=
1900
+
<span class="keyword">private</span>
1874
1901
</span>
1875
1902
</code>
1876
1903
<ol>
···
1896
1923
<a href="#extension-decl-Foo" class="anchor"></a>
1897
1924
<code>
1898
1925
<span><span class="keyword">type</span>
1899
-
<a href="#type-poly_ext">poly_ext</a> +=
1926
+
<a href="#type-poly_ext">Ocamlary.poly_ext</a> +=
1900
1927
</span>
1901
1928
</code>
1902
1929
<ol>
···
1928
1955
<a href="#extension-decl-Quux" class="anchor"></a>
1929
1956
<code>
1930
1957
<span><span class="keyword">type</span>
1931
-
<a href="#type-poly_ext">poly_ext</a> +=
1958
+
<a href="#type-poly_ext">Ocamlary.poly_ext</a> +=
1932
1959
</span>
1933
1960
</code>
1934
1961
<ol>
···
1964
1991
<a href="#extension-decl-ZzzTop0" class="anchor"></a>
1965
1992
<code>
1966
1993
<span><span class="keyword">type</span>
1967
-
<a href="Ocamlary-ExtMod.html#type-t">ExtMod.t</a> +=
1994
+
<a href="Ocamlary-ExtMod.html#type-t">Ocamlary.ExtMod.t</a> +=
1995
+
1968
1996
</span>
1969
1997
</code>
1970
1998
<ol>
···
1985
2013
<a href="#extension-decl-ZzzTop" class="anchor"></a>
1986
2014
<code>
1987
2015
<span><span class="keyword">type</span>
1988
-
<a href="Ocamlary-ExtMod.html#type-t">ExtMod.t</a> +=
2016
+
<a href="Ocamlary-ExtMod.html#type-t">Ocamlary.ExtMod.t</a> +=
2017
+
1989
2018
</span>
1990
2019
</code>
1991
2020
<ol>
···
2019
2048
<code><span><span class="keyword">type</span> my_mod</span>
2020
2049
<span> =
2021
2050
<span>(<span class="keyword">module</span>
2022
-
<a href="Ocamlary-module-type-COLLECTION.html">COLLECTION</a>
2023
-
)
2051
+
<a href="Ocamlary-module-type-COLLECTION.html">Ocamlary.COLLECTION
2052
+
</a>)
2024
2053
</span>
2025
2054
</span>
2026
2055
</code>
···
2187
2216
<a href="#type-dep2" class="anchor"></a>
2188
2217
<code><span><span class="keyword">type</span> dep2</span>
2189
2218
<span> =
2190
-
<a href="Ocamlary-Dep4-module-type-T.html#type-b">Dep5(Dep4).Z.X.b</a>
2219
+
<a href="Ocamlary-Dep4-module-type-T.html#type-b">
2220
+
Ocamlary.Dep5(Ocamlary.Dep4).Z.X.b
2221
+
</a>
2191
2222
</span>
2192
2223
</code>
2193
2224
</div>
···
2234
2265
<a href="#type-dep4" class="anchor"></a>
2235
2266
<code><span><span class="keyword">type</span> dep4</span>
2236
2267
<span> =
2237
-
<a href="Ocamlary-Dep6-module-type-T-Y.html#type-d">Dep7(Dep6).M.Y.d
2268
+
<a href="Ocamlary-Dep6-module-type-T-Y.html#type-d">
2269
+
Ocamlary.Dep7(Ocamlary.Dep6).M.Y.d
2238
2270
</a>
2239
2271
</span>
2240
2272
</code>
···
2276
2308
<span class="keyword">type</span>
2277
2309
<a href="Ocamlary-module-type-Dep10.html">Dep10</a>
2278
2310
</span>
2279
-
<span> = <a href="Ocamlary-Dep8-module-type-T.html">Dep9(Dep8).T</a>
2280
-
<span class="keyword">with</span>
2311
+
<span> =
2312
+
<a href="Ocamlary-Dep8-module-type-T.html">
2313
+
Ocamlary.Dep9(Ocamlary.Dep8).T
2314
+
</a> <span class="keyword">with</span>
2281
2315
<span><span class="keyword">type</span>
2282
2316
<a href="Ocamlary-Dep8-module-type-T.html#type-t">t</a> = int
2283
2317
</span>
···
2320
2354
<span><span class="keyword">module</span>
2321
2355
<a href="Ocamlary-Dep13.html">Dep13</a>
2322
2356
</span>
2323
-
<span> : <a href="Ocamlary-Dep11-module-type-S.html">Dep12(Dep11).T</a>
2357
+
<span> :
2358
+
<a href="Ocamlary-Dep11-module-type-S.html">
2359
+
Ocamlary.Dep12(Ocamlary.Dep11).T
2360
+
</a>
2324
2361
</span>
2325
2362
</code>
2326
2363
</div>
···
2330
2367
<a href="#type-dep5" class="anchor"></a>
2331
2368
<code><span><span class="keyword">type</span> dep5</span>
2332
2369
<span> =
2333
-
<a href="Ocamlary-Dep11-module-type-S-class-c.html">Dep13.c</a>
2370
+
<a href="Ocamlary-Dep11-module-type-S-class-c.html">Ocamlary.Dep13.c
2371
+
</a>
2334
2372
</span>
2335
2373
</code>
2336
2374
</div>
···
2369
2407
<span><span class="keyword">module</span>
2370
2408
<a href="Ocamlary-With3.html">With3</a>
2371
2409
</span>
2372
-
<span> : <a href="Ocamlary-module-type-With1.html">With1</a>
2373
-
<span class="keyword">with</span>
2410
+
<span> : <a href="Ocamlary-module-type-With1.html">Ocamlary.With1</a>
2411
+
<span class="keyword">with</span>
2374
2412
<span><span class="keyword">module</span>
2375
2413
<a href="Ocamlary-module-type-With1-M.html">M</a> =
2376
-
<a href="Ocamlary-With2.html">With2</a>
2414
+
<a href="Ocamlary-With2.html">Ocamlary.With2</a>
2377
2415
</span>
2378
2416
</span>
2379
2417
</code>
···
2383
2421
<div class="spec type anchored" id="type-with1">
2384
2422
<a href="#type-with1" class="anchor"></a>
2385
2423
<code><span><span class="keyword">type</span> with1</span>
2386
-
<span> = <a href="Ocamlary-With3-N.html#type-t">With3.N.t</a></span>
2424
+
<span> = <a href="Ocamlary-With3-N.html#type-t">Ocamlary.With3.N.t</a>
2425
+
</span>
2387
2426
</code>
2388
2427
</div>
2389
2428
</div>
···
2394
2433
<span><span class="keyword">module</span>
2395
2434
<a href="Ocamlary-With4.html">With4</a>
2396
2435
</span>
2397
-
<span> : <a href="Ocamlary-module-type-With1.html">With1</a>
2398
-
<span class="keyword">with</span>
2436
+
<span> : <a href="Ocamlary-module-type-With1.html">Ocamlary.With1</a>
2437
+
<span class="keyword">with</span>
2399
2438
<span><span class="keyword">module</span>
2400
2439
<a href="Ocamlary-module-type-With1-M.html">M</a> :=
2401
-
<a href="Ocamlary-With2.html">With2</a>
2440
+
<a href="Ocamlary-With2.html">Ocamlary.With2</a>
2402
2441
</span>
2403
2442
</span>
2404
2443
</code>
···
2408
2447
<div class="spec type anchored" id="type-with2">
2409
2448
<a href="#type-with2" class="anchor"></a>
2410
2449
<code><span><span class="keyword">type</span> with2</span>
2411
-
<span> = <a href="Ocamlary-With4-N.html#type-t">With4.N.t</a></span>
2450
+
<span> = <a href="Ocamlary-With4-N.html#type-t">Ocamlary.With4.N.t</a>
2451
+
</span>
2412
2452
</code>
2413
2453
</div>
2414
2454
</div>
···
2463
2503
</span>
2464
2504
<span> =
2465
2505
2466
-
<a href="Ocamlary-With6-module-type-T.html">With7(With6).T</a>
2467
-
<span class="keyword">with</span>
2506
+
<a href="Ocamlary-With6-module-type-T.html">
2507
+
Ocamlary.With7(Ocamlary.With6).T
2508
+
</a>
2509
+
2510
+
<span class="keyword">with</span>
2468
2511
<span><span class="keyword">module</span>
2469
2512
<a href="Ocamlary-With6-module-type-T-M.html">M</a> =
2470
-
<a href="Ocamlary-With5.html">With5</a>
2471
-
</span> <span class="keyword">and</span>
2513
+
<a href="Ocamlary-With5.html">Ocamlary.With5</a>
2514
+
</span>
2515
+
2516
+
<span class="keyword">and</span>
2472
2517
<span><span class="keyword">type</span>
2473
2518
<a href="Ocamlary-With5-module-type-S.html#type-t">M.N.t</a> =
2474
-
<a href="Ocamlary-With5-N.html#type-t">With5.N.t</a>
2519
+
<a href="Ocamlary-With5-N.html#type-t">Ocamlary.With5.N.t</a>
2475
2520
</span>
2476
2521
</span>
2477
2522
</code>
···
2511
2556
<span class="keyword">type</span>
2512
2557
<a href="Ocamlary-module-type-With11.html">With11</a>
2513
2558
</span>
2514
-
<span> =
2515
-
<a href="Ocamlary-With10-module-type-T.html">With7(With10).T</a>
2516
-
<span class="keyword">with</span>
2559
+
<span> =
2560
+
2561
+
<a href="Ocamlary-With10-module-type-T.html">
2562
+
Ocamlary.With7(Ocamlary.With10).T
2563
+
</a>
2564
+
2565
+
<span class="keyword">with</span>
2517
2566
<span><span class="keyword">module</span>
2518
2567
<a href="Ocamlary-With10-module-type-T-M.html">M</a> =
2519
-
<a href="Ocamlary-With9.html">With9</a>
2520
-
</span> <span class="keyword">and</span>
2568
+
<a href="Ocamlary-With9.html">Ocamlary.With9</a>
2569
+
</span>
2570
+
2571
+
<span class="keyword">and</span>
2521
2572
<span><span class="keyword">type</span>
2522
2573
<a href="Ocamlary-With9-module-type-S.html#type-t">N.t</a> =
2523
2574
int
···
2545
2596
<summary class="spec include">
2546
2597
<code>
2547
2598
<span><span class="keyword">include</span>
2548
-
<a href="Ocamlary-module-type-NestedInclude1.html">NestedInclude1</a>
2599
+
<a href="Ocamlary-module-type-NestedInclude1.html">
2600
+
Ocamlary.NestedInclude1
2601
+
</a>
2549
2602
</span>
2550
2603
</code>
2551
2604
</summary>
···
2571
2624
<summary class="spec include">
2572
2625
<code>
2573
2626
<span><span class="keyword">include</span>
2574
-
<a href="Ocamlary-module-type-NestedInclude2.html">NestedInclude2</a>
2575
-
<span class="keyword">with</span>
2627
+
<a href="Ocamlary-module-type-NestedInclude2.html">
2628
+
Ocamlary.NestedInclude2
2629
+
</a> <span class="keyword">with</span>
2576
2630
<span><span class="keyword">type</span>
2577
2631
<a
2578
2632
href="Ocamlary-module-type-NestedInclude2.html#type-nested_include">
···
2626
2680
<span class="keyword">module</span> <span class="keyword">type</span>
2627
2681
<span class="keyword">of</span>
2628
2682
<a href="Ocamlary-DoubleInclude3-DoubleInclude2.html">
2629
-
DoubleInclude3.DoubleInclude2
2683
+
Ocamlary.DoubleInclude3.DoubleInclude2
2630
2684
</a>
2631
2685
</span>
2632
2686
</code>
···
2660
2714
<span><span class="keyword">include</span>
2661
2715
<span class="keyword">module</span> <span class="keyword">type</span>
2662
2716
<span class="keyword">of</span>
2663
-
<a href="Ocamlary-IncludeInclude1.html">IncludeInclude1</a>
2717
+
<a href="Ocamlary-IncludeInclude1.html">Ocamlary.IncludeInclude1</a>
2664
2718
</span>
2665
2719
</code>
2666
2720
</summary>
···
2699
2753
<summary class="spec include">
2700
2754
<code>
2701
2755
<span><span class="keyword">include</span>
2702
-
<a href="Ocamlary-module-type-IncludeInclude2.html">IncludeInclude2
2756
+
<a href="Ocamlary-module-type-IncludeInclude2.html">
2757
+
Ocamlary.IncludeInclude2
2703
2758
</a>
2704
2759
</span>
2705
2760
</code>
···
2931
2986
<div class="spec type extension anchored" id="extension-decl-C">
2932
2987
<a href="#extension-decl-C" class="anchor"></a>
2933
2988
<code>
2934
-
<span><span class="keyword">type</span> <a href="#type-new_t">new_t</a>
2935
-
+=
2989
+
<span><span class="keyword">type</span>
2990
+
<a href="#type-new_t">Ocamlary.new_t</a> +=
2936
2991
</span>
2937
2992
</code>
2938
2993
<ol>
···
2952
3007
<span class="keyword">type</span>
2953
3008
<a href="Ocamlary-module-type-TypeExtPruned.html">TypeExtPruned</a>
2954
3009
</span>
2955
-
<span> = <a href="Ocamlary-module-type-TypeExt.html">TypeExt</a>
3010
+
<span> =
3011
+
<a href="Ocamlary-module-type-TypeExt.html">Ocamlary.TypeExt</a>
2956
3012
<span class="keyword">with</span>
2957
3013
<span><span class="keyword">type</span>
2958
3014
<a href="Ocamlary-module-type-TypeExt.html#type-t">t</a> :=
2959
-
<a href="#type-new_t">new_t</a>
3015
+
<a href="#type-new_t">Ocamlary.new_t</a>
2960
3016
</span>
2961
3017
</span>
2962
3018
</code>
+2
-2
odoc/test/generators/html/Recent-X.html
+2
-2
odoc/test/generators/html/Recent-X.html
···
21
21
<a href="#module-L" class="anchor"></a>
22
22
<code>
23
23
<span><span class="keyword">module</span> L :=
24
-
<a href="Recent-Z-Y.html">Z.Y</a>
24
+
<a href="Recent-Z-Y.html">Recent.Z.Y</a>
25
25
</span>
26
26
</code>
27
27
</div>
···
48
48
<a href="#type-v" class="anchor"></a>
49
49
<code><span><span class="keyword">type</span> v</span>
50
50
<span> =
51
-
<span><a href="#type-u">u</a>
51
+
<span><a href="#type-u">Recent.X.u</a>
52
52
<a href="Recent-Z-Y-X.html#type-t">L.X.t</a>
53
53
</span>
54
54
</span>
+1
-1
odoc/test/generators/html/Recent-module-type-S1.html
+1
-1
odoc/test/generators/html/Recent-module-type-S1.html
···
30
30
<a href="#argument-1-_" class="anchor"></a>
31
31
<code><span><span class="keyword">module</span> </span>
32
32
<span><a href="Recent-module-type-S1-argument-1-_.html">_</a></span>
33
-
<span> : <a href="Recent-module-type-S.html">S</a></span>
33
+
<span> : <a href="Recent-module-type-S.html">Recent.S</a></span>
34
34
</code>
35
35
</div>
36
36
</div>
+7
-7
odoc/test/generators/html/Recent.html
+7
-7
odoc/test/generators/html/Recent.html
···
39
39
</span>
40
40
<span> = <span class="keyword">functor</span>
41
41
<span> (<a href="Recent-module-type-S1-argument-1-_.html">_</a>
42
-
: <a href="Recent-module-type-S.html">S</a>)
42
+
: <a href="Recent-module-type-S.html">Recent.S</a>)
43
43
<span class="arrow">-></span>
44
-
</span> <a href="Recent-module-type-S.html">S</a>
44
+
</span> <a href="Recent-module-type-S.html">Recent.S</a>
45
45
</span>
46
46
</code>
47
47
</div>
···
110
110
<a href="#type-gadt.A" class="anchor"></a>
111
111
<code><span>| </span>
112
112
<span><span class="constructor">A</span> :
113
-
<span>int <a href="#type-gadt">gadt</a></span>
113
+
<span>int <a href="#type-gadt">Recent.gadt</a></span>
114
114
</span>
115
115
</code>
116
116
</li>
···
119
119
<code><span>| </span>
120
120
<span><span class="constructor">B</span> : int
121
121
<span class="arrow">-></span>
122
-
<span>string <a href="#type-gadt">gadt</a></span>
122
+
<span>string <a href="#type-gadt">Recent.gadt</a></span>
123
123
</span>
124
124
</code>
125
125
<div class="def-doc"><span class="comment-delim">(*</span><p>foo</p>
···
139
139
</ol>
140
140
<code><span>}</span>
141
141
<span> <span class="arrow">-></span>
142
-
<span>unit <a href="#type-gadt">gadt</a></span>
142
+
<span>unit <a href="#type-gadt">Recent.gadt</a></span>
143
143
</span>
144
144
</code>
145
145
</li>
···
214
214
* float
215
215
</span> ]
216
216
</span> <span class="arrow">-></span>
217
-
<a href="#type-empty_conj">empty_conj</a>
217
+
<a href="#type-empty_conj">Recent.empty_conj</a>
218
218
</span>
219
219
</code>
220
220
</li>
···
237
237
<span>[< <span>`B of int & float</span> ]</span>
238
238
</span> ]
239
239
</span> <span class="arrow">-></span>
240
-
<a href="#type-conj">conj</a>
240
+
<a href="#type-conj">Recent.conj</a>
241
241
</span>
242
242
</code>
243
243
</li>
+1
-1
odoc/test/generators/html/Recent_impl.html
+1
-1
odoc/test/generators/html/Recent_impl.html
···
65
65
<div class="spec module anchored" id="module-B'">
66
66
<a href="#module-B'" class="anchor"></a>
67
67
<code><span><span class="keyword">module</span> B'</span>
68
-
<span> = <a href="Recent_impl-Foo-B.html">Foo.B</a></span>
68
+
<span> = <a href="Recent_impl-Foo-B.html">Recent_impl.Foo.B</a></span>
69
69
</code>
70
70
</div>
71
71
</div>
+23
-8
odoc/test/generators/html/Stop_dead_link_doc.html
+23
-8
odoc/test/generators/html/Stop_dead_link_doc.html
···
39
39
<code><span>| </span>
40
40
<span><span class="constructor">Bar</span>
41
41
<span class="keyword">of</span>
42
-
<a href="Stop_dead_link_doc-Foo.html#type-t">Foo.t</a>
42
+
<a href="Stop_dead_link_doc-Foo.html#type-t">
43
+
Stop_dead_link_doc.Foo.t
44
+
</a>
43
45
</span>
44
46
</code>
45
47
</li>
···
64
66
<a href="#type-bar.field" class="anchor"></a>
65
67
<code>
66
68
<span>field :
67
-
<a href="Stop_dead_link_doc-Foo.html#type-t">Foo.t</a>;
69
+
<a href="Stop_dead_link_doc-Foo.html#type-t">
70
+
Stop_dead_link_doc.Foo.t
71
+
</a>;
68
72
</span>
69
73
</code>
70
74
</li>
···
85
89
<code><span>| </span>
86
90
<span><span class="constructor">Bar_</span>
87
91
<span class="keyword">of</span> int *
88
-
<a href="Stop_dead_link_doc-Foo.html#type-t">Foo.t</a> * int
92
+
<a href="Stop_dead_link_doc-Foo.html#type-t">
93
+
Stop_dead_link_doc.Foo.t
94
+
</a> * int
89
95
</span>
90
96
</code>
91
97
</li>
···
104
110
<code><span>| </span>
105
111
<span><span class="constructor">Bar__</span>
106
112
<span class="keyword">of</span>
107
-
<span><a href="Stop_dead_link_doc-Foo.html#type-t">Foo.t</a> option
113
+
<span>
114
+
<a href="Stop_dead_link_doc-Foo.html#type-t">
115
+
Stop_dead_link_doc.Foo.t
116
+
</a> option
108
117
</span>
109
118
</span>
110
119
</code>
···
124
133
<code><span>| </span>
125
134
<span><span class="constructor">Bar</span>
126
135
<span class="keyword">of</span>
127
-
<span class="xref-unresolved">Another_Foo.t</span>
136
+
<span class="xref-unresolved">Stop_dead_link_doc.Another_Foo.t
137
+
</span>
128
138
</span>
129
139
</code>
130
140
</li>
···
149
159
<li id="type-another_bar.field" class="def record field anchored">
150
160
<a href="#type-another_bar.field" class="anchor"></a>
151
161
<code>
152
-
<span>field : <span class="xref-unresolved">Another_Foo.t</span>;
162
+
<span>field :
163
+
<span class="xref-unresolved">Stop_dead_link_doc.Another_Foo.t
164
+
</span>;
153
165
</span>
154
166
</code>
155
167
</li>
···
170
182
<code><span>| </span>
171
183
<span><span class="constructor">Bar_</span>
172
184
<span class="keyword">of</span> int *
173
-
<span class="xref-unresolved">Another_Foo.t</span> * int
185
+
<span class="xref-unresolved">Stop_dead_link_doc.Another_Foo.t
186
+
</span> * int
174
187
</span>
175
188
</code>
176
189
</li>
···
189
202
<code><span>| </span>
190
203
<span><span class="constructor">Bar__</span>
191
204
<span class="keyword">of</span>
192
-
<span><span class="xref-unresolved">Another_Foo.t</span> option
205
+
<span>
206
+
<span class="xref-unresolved">Stop_dead_link_doc.Another_Foo.t
207
+
</span> option
193
208
</span>
194
209
</span>
195
210
</code>
+3
-1
odoc/test/generators/html/Toplevel_comments.html
+3
-1
odoc/test/generators/html/Toplevel_comments.html
···
142
142
<span><span class="keyword">module</span>
143
143
<a href="Toplevel_comments-Alias.html">Alias</a>
144
144
</span>
145
-
<span> : <a href="Toplevel_comments-module-type-T.html">T</a></span>
145
+
<span> :
146
+
<a href="Toplevel_comments-module-type-T.html">Toplevel_comments.T</a>
147
+
</span>
146
148
</code>
147
149
</div><div class="spec-doc"><p>Doc of <code>Alias</code>.</p></div>
148
150
</div>
+36
-29
odoc/test/generators/html/Type.html
+36
-29
odoc/test/generators/html/Type.html
···
152
152
<div class="spec type anchored" id="type-instance">
153
153
<a href="#type-instance" class="anchor"></a>
154
154
<code><span><span class="keyword">type</span> instance</span>
155
-
<span> = <span>int <a href="#type-constructor">constructor</a></span>
155
+
<span> =
156
+
<span>int <a href="#type-constructor">Type.constructor</a></span>
156
157
</span>
157
158
</code>
158
159
</div>
···
163
164
<code><span><span class="keyword">type</span> long</span>
164
165
<span> =
165
166
166
-
<span><a href="#type-labeled_higher_order">labeled_higher_order</a>
167
+
<span>
168
+
<a href="#type-labeled_higher_order">Type.labeled_higher_order</a>
167
169
<span class="arrow">-></span>
168
170
</span>
169
171
170
172
<span>
171
173
<span>[ `Bar
172
-
<span><span>| `Baz</span> of <a href="#type-triple">triple</a>
174
+
<span><span>| `Baz</span> of <a href="#type-triple">Type.triple</a>
173
175
</span> ]
174
176
</span> <span class="arrow">-></span>
175
177
</span>
176
178
177
-
<span><a href="#type-pair">pair</a>
179
+
<span><a href="#type-pair">Type.pair</a>
178
180
<span class="arrow">-></span>
179
181
</span>
180
182
181
-
<span><a href="#type-labeled">labeled</a>
183
+
<span><a href="#type-labeled">Type.labeled</a>
182
184
<span class="arrow">-></span>
183
185
</span>
184
186
185
-
<span><a href="#type-higher_order">higher_order</a>
187
+
<span><a href="#type-higher_order">Type.higher_order</a>
186
188
<span class="arrow">-></span>
187
189
</span>
188
190
···
196
198
</span> <span class="arrow">-></span>
197
199
</span>
198
200
199
-
<span><a href="#type-nested_pair">nested_pair</a>
201
+
<span><a href="#type-nested_pair">Type.nested_pair</a>
200
202
<span class="arrow">-></span>
201
203
</span>
202
204
203
-
<span><a href="#type-arrow">arrow</a>
205
+
<span><a href="#type-arrow">Type.arrow</a>
204
206
<span class="arrow">-></span>
205
207
</span>
206
208
207
209
<span>string <span class="arrow">-></span></span>
208
210
209
-
<span><a href="#type-nested_pair">nested_pair</a> array</span>
211
+
<span><a href="#type-nested_pair">Type.nested_pair</a> array</span>
210
212
</span>
211
213
</code>
212
214
</div>
···
266
268
<code><span>| </span>
267
269
<span><span class="constructor">E</span>
268
270
<span class="keyword">of</span>
269
-
<a href="#type-variant_e">variant_e</a>
271
+
<a href="#type-variant_e">Type.variant_e</a>
270
272
</span>
271
273
</code>
272
274
</li>
···
298
300
<a href="#type-gadt.A" class="anchor"></a>
299
301
<code><span>| </span>
300
302
<span><span class="constructor">A</span> :
301
-
<span>int <a href="#type-gadt">gadt</a></span>
303
+
<span>int <a href="#type-gadt">Type.gadt</a></span>
302
304
</span>
303
305
</code>
304
306
</li>
···
307
309
<code><span>| </span>
308
310
<span><span class="constructor">B</span> : int
309
311
<span class="arrow">-></span>
310
-
<span>string <a href="#type-gadt">gadt</a></span>
312
+
<span>string <a href="#type-gadt">Type.gadt</a></span>
311
313
</span>
312
314
</code>
313
315
</li>
···
315
317
<a href="#type-gadt.C" class="anchor"></a>
316
318
<code><span>| </span>
317
319
<span><span class="constructor">C</span> :
318
-
<a href="#type-variant_c">variant_c</a>
320
+
<a href="#type-variant_c">Type.variant_c</a>
319
321
<span class="arrow">-></span>
320
-
<span>unit <a href="#type-gadt">gadt</a></span>
322
+
<span>unit <a href="#type-gadt">Type.gadt</a></span>
321
323
</span>
322
324
</code>
323
325
</li>
···
335
337
anchored"><a href="#type-degenerate_gadt.A" class="anchor"></a>
336
338
<code><span>| </span>
337
339
<span><span class="constructor">A</span> :
338
-
<a href="#type-degenerate_gadt">degenerate_gadt</a>
340
+
<a href="#type-degenerate_gadt">Type.degenerate_gadt</a>
339
341
</span>
340
342
</code>
341
343
</li>
···
432
434
</span><span> = </span><span>[ </span>
433
435
</code>
434
436
<ol>
435
-
<li id="type-polymorphic_variant_extension.polymorphic_variant"
437
+
<li id="type-polymorphic_variant_extension.Type.polymorphic_variant"
436
438
class="def variant type anchored">
437
-
<a href="#type-polymorphic_variant_extension.polymorphic_variant"
439
+
<a href="#type-polymorphic_variant_extension.Type.polymorphic_variant"
438
440
class="anchor">
439
441
</a>
440
442
<code><span>| </span>
441
-
<span><a href="#type-polymorphic_variant">polymorphic_variant</a>
443
+
<span>
444
+
<a href="#type-polymorphic_variant">Type.polymorphic_variant</a>
442
445
</span>
443
446
</code>
444
447
</li>
···
478
481
<span>[> </span>
479
482
</code>
480
483
<ol>
481
-
<li id="type-private_extenion.polymorphic_variant" class="def variant
482
-
type anchored">
483
-
<a href="#type-private_extenion.polymorphic_variant" class="anchor">
484
+
<li id="type-private_extenion.Type.polymorphic_variant" class="
485
+
def variant type anchored">
486
+
<a href="#type-private_extenion.Type.polymorphic_variant"
487
+
class="anchor">
484
488
</a>
485
489
<code><span>| </span>
486
-
<span><a href="#type-polymorphic_variant">polymorphic_variant</a>
490
+
<span>
491
+
<a href="#type-polymorphic_variant">Type.polymorphic_variant</a>
487
492
</span>
488
493
</code>
489
494
</li>
···
518
523
<code><span><span class="keyword">type</span> module_</span>
519
524
<span> =
520
525
<span>(<span class="keyword">module</span>
521
-
<a href="Type-module-type-X.html">X</a>)
526
+
<a href="Type-module-type-X.html">Type.X</a>)
522
527
</span>
523
528
</span>
524
529
</code>
···
530
535
<code><span><span class="keyword">type</span> module_substitution</span>
531
536
<span> =
532
537
<span>(<span class="keyword">module</span>
533
-
<a href="Type-module-type-X.html">X</a>
538
+
<a href="Type-module-type-X.html">Type.X</a>
534
539
<span class="keyword">with</span> <span class="keyword">type</span>
535
540
<a href="Type-module-type-X.html#type-t">t</a> = int
536
541
<span class="keyword">and</span> <span class="keyword">type</span>
···
581
586
<a href="#type-using_binary" class="anchor"></a>
582
587
<code><span><span class="keyword">type</span> using_binary</span>
583
588
<span> =
584
-
<span><span>(int, int)</span> <a href="#type-binary">binary</a></span>
589
+
<span><span>(int, int)</span> <a href="#type-binary">Type.binary</a>
590
+
</span>
585
591
</span>
586
592
</code>
587
593
</div>
···
667
673
<span> <span class="keyword">constraint</span>
668
674
<span class="type-var">'a</span> =
669
675
<span>[<
670
-
<a href="#type-polymorphic_variant">polymorphic_variant</a> ]
676
+
<a href="#type-polymorphic_variant">Type.polymorphic_variant</a>
677
+
]
671
678
</span>
672
679
</span>
673
680
</code>
···
753
760
<a href="#extension-decl-Extension" class="anchor"></a>
754
761
<code>
755
762
<span><span class="keyword">type</span>
756
-
<a href="#type-extensible">extensible</a> +=
763
+
<a href="#type-extensible">Type.extensible</a> +=
757
764
</span>
758
765
</code>
759
766
<ol>
···
796
803
<code><span>| </span>
797
804
<span><span class="constructor">A</span>
798
805
<span class="keyword">of</span>
799
-
<a href="#type-recursive">recursive</a>
806
+
<a href="#type-recursive">Type.recursive</a>
800
807
</span>
801
808
</code>
802
809
</li>
···
815
822
<code><span>| </span>
816
823
<span><span class="constructor">B</span>
817
824
<span class="keyword">of</span>
818
-
<a href="#type-mutually">mutually</a>
825
+
<a href="#type-mutually">Type.mutually</a>
819
826
</span>
820
827
</code>
821
828
</li>
+5
-5
odoc/test/generators/latex/Functor.tex
+5
-5
odoc/test/generators/latex/Functor.tex
···
10
10
\label{Functor-module-type-S1--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
11
11
\end{ocamlindent}%
12
12
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
13
-
\label{Functor--module-F1}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F1]{\ocamlinlinecode{F1}}}\ocamlcodefragment{ (\hyperref[Functor-F1-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}) : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}}\\
14
-
\label{Functor--module-F2}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F2]{\ocamlinlinecode{F2}}}\ocamlcodefragment{ (\hyperref[Functor-F2-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}) : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Functor-module-type-S--type-t]{\ocamlinlinecode{t}} = \hyperref[Functor-F2-argument-1-Arg--type-t]{\ocamlinlinecode{Arg.\allowbreak{}t}}}\\
15
-
\label{Functor--module-F3}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F3]{\ocamlinlinecode{F3}}}\ocamlcodefragment{ (\hyperref[Functor-F3-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
16
-
\label{Functor--module-F4}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F4]{\ocamlinlinecode{F4}}}\ocamlcodefragment{ (\hyperref[Functor-F4-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}) : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}}\\
17
-
\label{Functor--module-F5}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F5]{\ocamlinlinecode{F5}}}\ocamlcodefragment{ () : \hyperref[Functor-module-type-S]{\ocamlinlinecode{S}}}\\
13
+
\label{Functor--module-F1}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F1]{\ocamlinlinecode{F1}}}\ocamlcodefragment{ (\hyperref[Functor-F1-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}) : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}}\\
14
+
\label{Functor--module-F2}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F2]{\ocamlinlinecode{F2}}}\ocamlcodefragment{ (\hyperref[Functor-F2-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}) : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Functor-module-type-S--type-t]{\ocamlinlinecode{t}} = \hyperref[Functor-F2-argument-1-Arg--type-t]{\ocamlinlinecode{Arg.\allowbreak{}t}}}\\
15
+
\label{Functor--module-F3}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F3]{\ocamlinlinecode{F3}}}\ocamlcodefragment{ (\hyperref[Functor-F3-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
16
+
\label{Functor--module-F4}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F4]{\ocamlinlinecode{F4}}}\ocamlcodefragment{ (\hyperref[Functor-F4-argument-1-Arg]{\ocamlinlinecode{Arg}} : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}) : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}}\\
17
+
\label{Functor--module-F5}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor-F5]{\ocamlinlinecode{F5}}}\ocamlcodefragment{ () : \hyperref[Functor-module-type-S]{\ocamlinlinecode{Functor.\allowbreak{}S}}}\\
18
18
19
19
\input{Functor.F1.tex}
20
20
\input{Functor.F2.tex}
+1
-1
odoc/test/generators/latex/Functor2.tex
+1
-1
odoc/test/generators/latex/Functor2.tex
···
2
2
\label{Functor2--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Functor2-module-type-S]{\ocamlinlinecode{S}}}\label{Functor2-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Functor2-module-type-S--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
3
3
\end{ocamlindent}%
4
4
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
5
-
\label{Functor2--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor2-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ (\hyperref[Functor2-X-argument-1-Y]{\ocamlinlinecode{Y}} : \hyperref[Functor2-module-type-S]{\ocamlinlinecode{S}}) (\hyperref[Functor2-X-argument-2-Z]{\ocamlinlinecode{Z}} : \hyperref[Functor2-module-type-S]{\ocamlinlinecode{S}}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
5
+
\label{Functor2--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor2-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ (\hyperref[Functor2-X-argument-1-Y]{\ocamlinlinecode{Y}} : \hyperref[Functor2-module-type-S]{\ocamlinlinecode{Functor2.\allowbreak{}S}}) (\hyperref[Functor2-X-argument-2-Z]{\ocamlinlinecode{Z}} : \hyperref[Functor2-module-type-S]{\ocamlinlinecode{Functor2.\allowbreak{}S}}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
6
6
\label{Functor2--module-type-XF}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Functor2-module-type-XF]{\ocamlinlinecode{XF}}}\label{Functor2-module-type-XF}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\subsubsection{Parameters\label{Functor2-module-type-XF--parameters_2}}%
7
7
\label{Functor2-module-type-XF--argument-1-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Functor2-module-type-XF-argument-1-Y]{\ocamlinlinecode{Y}}}\label{Functor2-module-type-XF-argument-1-Y}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Functor2-module-type-XF-argument-1-Y--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
8
8
\end{ocamlindent}%
+1
-1
odoc/test/generators/latex/Functor_ml.Foo'.tex
+1
-1
odoc/test/generators/latex/Functor_ml.Foo'.tex
···
4
4
\end{ocamlindent}%
5
5
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
6
6
\subsection{Signature\label{Functor_ml-Foo'--signature}}%
7
-
\label{Functor_ml-Foo'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Functor_ml-Bar--type-t]{\ocamlinlinecode{Bar.\allowbreak{}t}}}\\
7
+
\label{Functor_ml-Foo'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Functor_ml-Bar--type-t]{\ocamlinlinecode{Functor\_\allowbreak{}ml.\allowbreak{}Bar.\allowbreak{}t}}}\\
8
8
9
9
+7
-7
odoc/test/generators/latex/Include.tex
+7
-7
odoc/test/generators/latex/Include.tex
···
2
2
\label{Include--module-type-Not_inlined}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Not_inlined]{\ocamlinlinecode{Not\_\allowbreak{}inlined}}}\label{Include-module-type-Not_inlined}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include-module-type-Not_inlined--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
3
3
\end{ocamlindent}%
4
4
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
5
-
\ocamltag{keyword}{include} \hyperref[Include-module-type-Not_inlined]{\ocamlinlinecode{Not\_\allowbreak{}inlined}}\label{Include--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
5
+
\ocamltag{keyword}{include} \hyperref[Include-module-type-Not_inlined]{\ocamlinlinecode{Include.\allowbreak{}Not\_\allowbreak{}inlined}}\label{Include--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
6
6
\label{Include--module-type-Inlined}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Inlined]{\ocamlinlinecode{Inlined}}}\label{Include-module-type-Inlined}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include-module-type-Inlined--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u}\\
7
7
\end{ocamlindent}%
8
8
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
9
-
\ocamltag{keyword}{include} \hyperref[Include-module-type-Inlined]{\ocamlinlinecode{Inlined}}\label{Include--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u}\\
9
+
\ocamltag{keyword}{include} \hyperref[Include-module-type-Inlined]{\ocamlinlinecode{Include.\allowbreak{}Inlined}}\label{Include--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u}\\
10
10
\label{Include--module-type-Not_inlined_and_closed}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Not_inlined_and_closed]{\ocamlinlinecode{Not\_\allowbreak{}inlined\_\allowbreak{}and\_\allowbreak{}closed}}}\label{Include-module-type-Not_inlined_and_closed}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include-module-type-Not_inlined_and_closed--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} v}\\
11
11
\end{ocamlindent}%
12
12
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
13
-
\ocamltag{keyword}{include} \hyperref[Include-module-type-Not_inlined_and_closed]{\ocamlinlinecode{Not\_\allowbreak{}inlined\_\allowbreak{}and\_\allowbreak{}closed}}\label{Include--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} v}\\
13
+
\ocamltag{keyword}{include} \hyperref[Include-module-type-Not_inlined_and_closed]{\ocamlinlinecode{Include.\allowbreak{}Not\_\allowbreak{}inlined\_\allowbreak{}and\_\allowbreak{}closed}}\label{Include--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} v}\\
14
14
\label{Include--module-type-Not_inlined_and_opened}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Not_inlined_and_opened]{\ocamlinlinecode{Not\_\allowbreak{}inlined\_\allowbreak{}and\_\allowbreak{}opened}}}\label{Include-module-type-Not_inlined_and_opened}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include-module-type-Not_inlined_and_opened--type-w}\ocamlcodefragment{\ocamltag{keyword}{type} w}\\
15
15
\end{ocamlindent}%
16
16
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
17
-
\ocamltag{keyword}{include} \hyperref[Include-module-type-Not_inlined_and_opened]{\ocamlinlinecode{Not\_\allowbreak{}inlined\_\allowbreak{}and\_\allowbreak{}opened}}\label{Include--type-w}\ocamlcodefragment{\ocamltag{keyword}{type} w}\\
18
-
\label{Include--module-type-Inherent_Module}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Inherent\_\allowbreak{}Module}}}\label{Include-module-type-Inherent_Module}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include-module-type-Inherent_Module--val-a}\ocamlcodefragment{\ocamltag{keyword}{val} a : \hyperref[Include--type-t]{\ocamlinlinecode{t}}}\\
17
+
\ocamltag{keyword}{include} \hyperref[Include-module-type-Not_inlined_and_opened]{\ocamlinlinecode{Include.\allowbreak{}Not\_\allowbreak{}inlined\_\allowbreak{}and\_\allowbreak{}opened}}\label{Include--type-w}\ocamlcodefragment{\ocamltag{keyword}{type} w}\\
18
+
\label{Include--module-type-Inherent_Module}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Inherent\_\allowbreak{}Module}}}\label{Include-module-type-Inherent_Module}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include-module-type-Inherent_Module--val-a}\ocamlcodefragment{\ocamltag{keyword}{val} a : \hyperref[Include--type-t]{\ocamlinlinecode{Include.\allowbreak{}t}}}\\
19
19
\end{ocamlindent}%
20
20
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
21
-
\ocamltag{keyword}{include} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Inherent\_\allowbreak{}Module}}\label{Include--module-type-Dorminant_Module}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Dorminant_Module]{\ocamlinlinecode{Dorminant\_\allowbreak{}Module}}}\label{Include-module-type-Dorminant_Module}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Inherent\_\allowbreak{}Module}}\label{Include-module-type-Dorminant_Module--val-a}\ocamlcodefragment{\ocamltag{keyword}{val} a : \hyperref[Include--type-u]{\ocamlinlinecode{u}}}\\
21
+
\ocamltag{keyword}{include} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Include.\allowbreak{}Inherent\_\allowbreak{}Module}}\label{Include--module-type-Dorminant_Module}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Include-module-type-Dorminant_Module]{\ocamlinlinecode{Dorminant\_\allowbreak{}Module}}}\label{Include-module-type-Dorminant_Module}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Include.\allowbreak{}Inherent\_\allowbreak{}Module}}\label{Include-module-type-Dorminant_Module--val-a}\ocamlcodefragment{\ocamltag{keyword}{val} a : \hyperref[Include--type-u]{\ocamlinlinecode{Include.\allowbreak{}u}}}\\
22
22
\end{ocamlindent}%
23
23
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
24
-
\ocamltag{keyword}{include} \hyperref[Include-module-type-Dorminant_Module]{\ocamlinlinecode{Dorminant\_\allowbreak{}Module}}\ocamltag{keyword}{include} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Inherent\_\allowbreak{}Module}}\label{Include--val-a}\ocamlcodefragment{\ocamltag{keyword}{val} a : \hyperref[Include--type-u]{\ocamlinlinecode{u}}}\\
24
+
\ocamltag{keyword}{include} \hyperref[Include-module-type-Dorminant_Module]{\ocamlinlinecode{Include.\allowbreak{}Dorminant\_\allowbreak{}Module}}\ocamltag{keyword}{include} \hyperref[Include-module-type-Inherent_Module]{\ocamlinlinecode{Include.\allowbreak{}Inherent\_\allowbreak{}Module}}\label{Include--val-a}\ocamlcodefragment{\ocamltag{keyword}{val} a : \hyperref[Include--type-u]{\ocamlinlinecode{Include.\allowbreak{}u}}}\\
25
25
26
26
+3
-3
odoc/test/generators/latex/Include2.tex
+3
-3
odoc/test/generators/latex/Include2.tex
···
3
3
\end{ocamlindent}%
4
4
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Comment about X that should not appear when including X below.\end{ocamlindent}%
5
5
\medbreak
6
-
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Include2-X]{\ocamlinlinecode{X}} \ocamltag{keyword}{end}\label{Include2--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = int}\\
6
+
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Include2-X]{\ocamlinlinecode{Include2.\allowbreak{}X}} \ocamltag{keyword}{end}\label{Include2--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = int}\\
7
7
\label{Include2--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Include2-Y]{\ocamlinlinecode{Y}}}\label{Include2-Y}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Include2-Y--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
8
8
\end{ocamlindent}%
9
9
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Top-comment of Y.\end{ocamlindent}%
10
10
\medbreak
11
-
\label{Include2--module-Y_include_synopsis}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Include2-Y_include_synopsis]{\ocamlinlinecode{Y\_\allowbreak{}include\_\allowbreak{}synopsis}}}\label{Include2-Y_include_synopsis}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Include2-Y]{\ocamlinlinecode{Y}} \ocamltag{keyword}{end}\label{Include2-Y_include_synopsis--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Include2-Y--type-t]{\ocamlinlinecode{Y.\allowbreak{}t}}}\\
11
+
\label{Include2--module-Y_include_synopsis}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Include2-Y_include_synopsis]{\ocamlinlinecode{Y\_\allowbreak{}include\_\allowbreak{}synopsis}}}\label{Include2-Y_include_synopsis}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Include2-Y]{\ocamlinlinecode{Include2.\allowbreak{}Y}} \ocamltag{keyword}{end}\label{Include2-Y_include_synopsis--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Include2-Y--type-t]{\ocamlinlinecode{Include2.\allowbreak{}Y.\allowbreak{}t}}}\\
12
12
\end{ocamlindent}%
13
13
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}The \ocamlinlinecode{include Y} below should have the synopsis from \ocamlinlinecode{Y}'s top-comment attached to it.\end{ocamlindent}%
14
14
\medbreak
15
-
\label{Include2--module-Y_include_doc}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Include2-Y_include_doc]{\ocamlinlinecode{Y\_\allowbreak{}include\_\allowbreak{}doc}}}\label{Include2-Y_include_doc}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}Doc attached to \ocamlinlinecode{include Y}. \ocamlinlinecode{Y}'s top-comment shouldn't appear here.\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Include2-Y]{\ocamlinlinecode{Y}} \ocamltag{keyword}{end}\label{Include2-Y_include_doc--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Include2-Y--type-t]{\ocamlinlinecode{Y.\allowbreak{}t}}}\\
15
+
\label{Include2--module-Y_include_doc}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Include2-Y_include_doc]{\ocamlinlinecode{Y\_\allowbreak{}include\_\allowbreak{}doc}}}\label{Include2-Y_include_doc}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}Doc attached to \ocamlinlinecode{include Y}. \ocamlinlinecode{Y}'s top-comment shouldn't appear here.\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Include2-Y]{\ocamlinlinecode{Include2.\allowbreak{}Y}} \ocamltag{keyword}{end}\label{Include2-Y_include_doc--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Include2-Y--type-t]{\ocamlinlinecode{Include2.\allowbreak{}Y.\allowbreak{}t}}}\\
16
16
\end{ocamlindent}%
17
17
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
18
18
+4
-4
odoc/test/generators/latex/Include_sections.tex
+4
-4
odoc/test/generators/latex/Include_sections.tex
···
15
15
\medbreak
16
16
Let's include \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{\ocamlinlinecode{Something}}[p\pageref*{Include_sections-module-type-Something}]} once
17
17
18
-
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Something}}\subsection{Something 1\label{Include_sections--something-1_2}}%
18
+
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Include\_\allowbreak{}sections.\allowbreak{}Something}}\subsection{Something 1\label{Include_sections--something-1_2}}%
19
19
foo
20
20
21
21
\subsubsection{Something 2\label{Include_sections--something-2_2}}%
···
25
25
\subsection{Second include\label{Include_sections--second-include}}%
26
26
Let's include \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{\ocamlinlinecode{Something}}[p\pageref*{Include_sections-module-type-Something}]} a second time: the heading level should be shift here.
27
27
28
-
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Something}}\subsection{Something 1\label{Include_sections--something-1_3}}%
28
+
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Include\_\allowbreak{}sections.\allowbreak{}Something}}\subsection{Something 1\label{Include_sections--something-1_3}}%
29
29
foo
30
30
31
31
\subsubsection{Something 2\label{Include_sections--something-2_3}}%
···
35
35
\subsubsection{Third include\label{Include_sections--third-include}}%
36
36
Shifted some more.
37
37
38
-
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Something}}\subsection{Something 1\label{Include_sections--something-1_4}}%
38
+
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Include\_\allowbreak{}sections.\allowbreak{}Something}}\subsection{Something 1\label{Include_sections--something-1_4}}%
39
39
foo
40
40
41
41
\subsubsection{Something 2\label{Include_sections--something-2_4}}%
···
44
44
45
45
And let's include it again, but without inlining it this time: the ToC shouldn't grow.
46
46
47
-
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Something}}\label{Include_sections--val-something}\ocamlcodefragment{\ocamltag{keyword}{val} something : unit}\\
47
+
\ocamltag{keyword}{include} \hyperref[Include_sections-module-type-Something]{\ocamlinlinecode{Include\_\allowbreak{}sections.\allowbreak{}Something}}\label{Include_sections--val-something}\ocamlcodefragment{\ocamltag{keyword}{val} something : unit}\\
48
48
\subsection{Something 1\label{Include_sections--something-1_5}}%
49
49
foo
50
50
+6
-6
odoc/test/generators/latex/Labels.tex
+6
-6
odoc/test/generators/latex/Labels.tex
···
6
6
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
7
7
\label{Labels--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\begin{ocamlindent}Attached to type\end{ocamlindent}%
8
8
\medbreak
9
-
\label{Labels--val-f}\ocamlcodefragment{\ocamltag{keyword}{val} f : \hyperref[Labels--type-t]{\ocamlinlinecode{t}}}\begin{ocamlindent}Attached to value\end{ocamlindent}%
9
+
\label{Labels--val-f}\ocamlcodefragment{\ocamltag{keyword}{val} f : \hyperref[Labels--type-t]{\ocamlinlinecode{Labels.\allowbreak{}t}}}\begin{ocamlindent}Attached to value\end{ocamlindent}%
10
10
\medbreak
11
-
\label{Labels--val-e}\ocamlcodefragment{\ocamltag{keyword}{val} e : unit \ocamltag{arrow}{$\rightarrow$} \hyperref[Labels--type-t]{\ocamlinlinecode{t}}}\begin{ocamlindent}Attached to external\end{ocamlindent}%
11
+
\label{Labels--val-e}\ocamlcodefragment{\ocamltag{keyword}{val} e : unit \ocamltag{arrow}{$\rightarrow$} \hyperref[Labels--type-t]{\ocamlinlinecode{Labels.\allowbreak{}t}}}\begin{ocamlindent}Attached to external\end{ocamlindent}%
12
12
\medbreak
13
13
\label{Labels--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Labels-module-type-S]{\ocamlinlinecode{S}}}\label{Labels-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\subsubsection{Attached to module type\label{Labels-module-type-S--L6}}%
14
14
\end{ocamlindent}%
···
20
20
\label{Labels--exception-E}\ocamlcodefragment{\ocamltag{keyword}{exception} \ocamltag{exception}{E}}\begin{ocamlindent}Attached to exception\end{ocamlindent}%
21
21
\medbreak
22
22
\label{Labels--type-x}\ocamlcodefragment{\ocamltag{keyword}{type} x = .\allowbreak{}.\allowbreak{}}\\
23
-
\label{Labels--extension-decl-X}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Labels--type-x]{\ocamlinlinecode{x}} += }\\
23
+
\label{Labels--extension-decl-X}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Labels--type-x]{\ocamlinlinecode{Labels.\allowbreak{}x}} += }\\
24
24
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{X}}\label{Labels--extension-X}\\
25
25
\end{ocamltabular}%
26
26
\\
27
27
\begin{ocamlindent}Attached to extension\end{ocamlindent}%
28
28
\medbreak
29
-
\label{Labels--module-S}\ocamlcodefragment{\ocamltag{keyword}{module} S := \hyperref[Labels-A]{\ocamlinlinecode{A}}}\begin{ocamlindent}Attached to module subst\end{ocamlindent}%
29
+
\label{Labels--module-S}\ocamlcodefragment{\ocamltag{keyword}{module} S := \hyperref[Labels-A]{\ocamlinlinecode{Labels.\allowbreak{}A}}}\begin{ocamlindent}Attached to module subst\end{ocamlindent}%
30
30
\medbreak
31
-
\label{Labels--type-s}\ocamlcodefragment{\ocamltag{keyword}{type} s := \hyperref[Labels--type-t]{\ocamlinlinecode{t}}}\begin{ocamlindent}Attached to type subst\end{ocamlindent}%
31
+
\label{Labels--type-s}\ocamlcodefragment{\ocamltag{keyword}{type} s := \hyperref[Labels--type-t]{\ocamlinlinecode{Labels.\allowbreak{}t}}}\begin{ocamlindent}Attached to type subst\end{ocamlindent}%
32
32
\medbreak
33
33
\label{Labels--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u = }\\
34
34
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A'}}\label{Labels--type-u.A'}& Attached to constructor\\
35
35
\end{ocamltabular}%
36
36
\\
37
37
\label{Labels--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} v = \{}\\
38
-
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlinlinecode{f : \hyperref[Labels--type-t]{\ocamlinlinecode{t}};\allowbreak{}}\label{Labels--type-v.f}& Attached to field\\
38
+
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlinlinecode{f : \hyperref[Labels--type-t]{\ocamlinlinecode{Labels.\allowbreak{}t}};\allowbreak{}}\label{Labels--type-v.f}& Attached to field\\
39
39
\end{ocamltabular}%
40
40
\\
41
41
\ocamlcodefragment{\}}\\
+2
-2
odoc/test/generators/latex/Module.tex
+2
-2
odoc/test/generators/latex/Module.tex
···
12
12
\end{ocamlindent}%
13
13
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
14
14
\label{Module--module-type-S1}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S1}\\
15
-
\label{Module--module-type-S2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S2 = \hyperref[Module-module-type-S]{\ocamlinlinecode{S}}}\\
15
+
\label{Module--module-type-S2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S2 = \hyperref[Module-module-type-S]{\ocamlinlinecode{Module.\allowbreak{}S}}}\\
16
16
\label{Module--module-type-S3}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module-module-type-S3]{\ocamlinlinecode{S3}}}\label{Module-module-type-S3}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module-module-type-S3--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = int}\\
17
17
\label{Module-module-type-S3--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u = string}\\
18
18
\label{Module-module-type-S3--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} 'a v}\\
···
49
49
\label{Module-module-type-S7--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u}\\
50
50
\label{Module-module-type-S7--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} 'a v}\\
51
51
\label{Module-module-type-S7--type-w}\ocamlcodefragment{\ocamltag{keyword}{type} ('a,\allowbreak{} 'b) w}\\
52
-
\label{Module-module-type-S7--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Module-M']{\ocamlinlinecode{M'}}}\\
52
+
\label{Module-module-type-S7--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Module-M']{\ocamlinlinecode{Module.\allowbreak{}M'}}}\\
53
53
\end{ocamlindent}%
54
54
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
55
55
\label{Module--module-type-S8}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module-module-type-S8]{\ocamlinlinecode{S8}}}\label{Module-module-type-S8}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module-module-type-S8--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
+2
-2
odoc/test/generators/latex/Module_type_alias.tex
+2
-2
odoc/test/generators/latex/Module_type_alias.tex
···
12
12
\label{Module_type_alias-module-type-B--type-b}\ocamlcodefragment{\ocamltag{keyword}{type} b}\\
13
13
\end{ocamlindent}%
14
14
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
15
-
\label{Module_type_alias--module-type-D}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} D = \hyperref[Module_type_alias-module-type-A]{\ocamlinlinecode{A}}}\\
15
+
\label{Module_type_alias--module-type-D}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} D = \hyperref[Module_type_alias-module-type-A]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}alias.\allowbreak{}A}}}\\
16
16
\label{Module_type_alias--module-type-E}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_alias-module-type-E]{\ocamlinlinecode{E}}}\label{Module_type_alias-module-type-E}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\subsubsection{Parameters\label{Module_type_alias-module-type-E--parameters_2}}%
17
17
\label{Module_type_alias-module-type-E--argument-1-F}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_alias-module-type-E-argument-1-F]{\ocamlinlinecode{F}}}\label{Module_type_alias-module-type-E-argument-1-F}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_alias-module-type-E-argument-1-F--type-f}\ocamlcodefragment{\ocamltag{keyword}{type} f}\\
18
18
\end{ocamlindent}%
···
32
32
\label{Module_type_alias-module-type-G--type-a}\ocamlcodefragment{\ocamltag{keyword}{type} a}\\
33
33
\end{ocamlindent}%
34
34
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
35
-
\label{Module_type_alias--module-type-I}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} I = \hyperref[Module_type_alias-module-type-B]{\ocamlinlinecode{B}}}\\
35
+
\label{Module_type_alias--module-type-I}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} I = \hyperref[Module_type_alias-module-type-B]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}alias.\allowbreak{}B}}}\\
36
36
37
37
+1
-1
odoc/test/generators/latex/Module_type_of.T.tex
+1
-1
odoc/test/generators/latex/Module_type_of.T.tex
···
2
2
\label{Module_type_of-T--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_of-T-module-type-T]{\ocamlinlinecode{T}}}\label{Module_type_of-T-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_of-T-module-type-T--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
3
3
\end{ocamlindent}%
4
4
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
5
-
\label{Module_type_of-T--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Module_type_of-X]{\ocamlinlinecode{X}}}\\
5
+
\label{Module_type_of-T--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Module_type_of-X]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}of.\allowbreak{}X}}}\\
6
6
\label{Module_type_of-T--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_of-T-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Module_type_of-X]{\ocamlinlinecode{M}} \ocamltag{keyword}{end}}\\
7
7
8
8
\input{Module_type_of.T.N.tex}
+1
-1
odoc/test/generators/latex/Module_type_of.tex
+1
-1
odoc/test/generators/latex/Module_type_of.tex
···
10
10
\label{Module_type_of-X--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u}\\
11
11
\end{ocamlindent}%
12
12
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
13
-
\label{Module_type_of--module-T}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_of-T]{\ocamlinlinecode{T}}}\ocamlcodefragment{ : \hyperref[Module_type_of-module-type-S]{\ocamlinlinecode{S}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Module_type_of-module-type-S-M]{\ocamlinlinecode{M}} = \hyperref[Module_type_of-X]{\ocamlinlinecode{X}}}\\
13
+
\label{Module_type_of--module-T}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_of-T]{\ocamlinlinecode{T}}}\ocamlcodefragment{ : \hyperref[Module_type_of-module-type-S]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}of.\allowbreak{}S}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Module_type_of-module-type-S-M]{\ocamlinlinecode{M}} = \hyperref[Module_type_of-X]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}of.\allowbreak{}X}}}\\
14
14
15
15
\input{Module_type_of.T.tex}
+6
-6
odoc/test/generators/latex/Module_type_subst.tex
+6
-6
odoc/test/generators/latex/Module_type_subst.tex
···
1
1
\section{Module \ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst}}\label{Module_type_subst}%
2
2
\label{Module_type_subst--module-Local}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Local]{\ocamlinlinecode{Local}}}\label{Module_type_subst-Local}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Local--type-local}\ocamlcodefragment{\ocamltag{keyword}{type} local := int * int}\\
3
-
\label{Module_type_subst-Local--module-type-local}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Local-module-type-local]{\ocamlinlinecode{local}}}\label{Module_type_subst-Local-module-type-local}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Local-module-type-local--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Module_type_subst-Local--type-local]{\ocamlinlinecode{local}}}\\
3
+
\label{Module_type_subst-Local--module-type-local}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Local-module-type-local]{\ocamlinlinecode{local}}}\label{Module_type_subst-Local-module-type-local}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Local-module-type-local--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Module_type_subst-Local--type-local]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst.\allowbreak{}Local.\allowbreak{}local}}}\\
4
4
\end{ocamlindent}%
5
5
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
6
-
\label{Module_type_subst-Local--module-type-w}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} w = \hyperref[Module_type_subst-Local-module-type-local]{\ocamlinlinecode{local}}}\\
6
+
\label{Module_type_subst-Local--module-type-w}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} w = \hyperref[Module_type_subst-Local-module-type-local]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst.\allowbreak{}Local.\allowbreak{}local}}}\\
7
7
\label{Module_type_subst-Local--module-type-s}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Local-module-type-s]{\ocamlinlinecode{s}}}\label{Module_type_subst-Local-module-type-s}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
8
8
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
9
9
\end{ocamlindent}%
···
14
14
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
15
15
\end{ocamlindent}%
16
16
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
17
-
\label{Module_type_subst-Basic--module-type-with_}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-with_]{\ocamlinlinecode{with\_\allowbreak{}}}}\label{Module_type_subst-Basic-module-type-with_}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-with_--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} T = \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{s}}}\\
17
+
\label{Module_type_subst-Basic--module-type-with_}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-with_]{\ocamlinlinecode{with\_\allowbreak{}}}}\label{Module_type_subst-Basic-module-type-with_}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-with_--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} T = \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst.\allowbreak{}s}}}\\
18
18
\end{ocamlindent}%
19
19
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
20
20
\label{Module_type_subst-Basic--module-type-u2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-u2]{\ocamlinlinecode{u2}}}\label{Module_type_subst-Basic-module-type-u2}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-u2--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-u2-module-type-T]{\ocamlinlinecode{T}}}\label{Module_type_subst-Basic-module-type-u2-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
···
27
27
\label{Module_type_subst-Basic-module-type-with_2--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Basic-module-type-with_2-M]{\ocamlinlinecode{M}}}\ocamlcodefragment{ : \hyperref[Module_type_subst-Basic-module-type-with_2-module-type-T]{\ocamlinlinecode{T}}}\\
28
28
\end{ocamlindent}%
29
29
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
30
-
\label{Module_type_subst-Basic--module-type-a}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-a]{\ocamlinlinecode{a}}}\label{Module_type_subst-Basic-module-type-a}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-a--module-type-b}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} b = \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{s}}}\\
30
+
\label{Module_type_subst-Basic--module-type-a}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-a]{\ocamlinlinecode{a}}}\label{Module_type_subst-Basic-module-type-a}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-a--module-type-b}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} b = \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst.\allowbreak{}s}}}\\
31
31
\label{Module_type_subst-Basic-module-type-a--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Basic-module-type-a-M]{\ocamlinlinecode{M}}}\ocamlcodefragment{ : \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{b}}}\\
32
32
\end{ocamlindent}%
33
33
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
34
-
\label{Module_type_subst-Basic--module-type-c}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-c]{\ocamlinlinecode{c}}}\label{Module_type_subst-Basic-module-type-c}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-c--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Basic-module-type-c-M]{\ocamlinlinecode{M}}}\ocamlcodefragment{ : \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{s}}}\\
34
+
\label{Module_type_subst-Basic--module-type-c}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Basic-module-type-c]{\ocamlinlinecode{c}}}\label{Module_type_subst-Basic-module-type-c}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Basic-module-type-c--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Basic-module-type-c-M]{\ocamlinlinecode{M}}}\ocamlcodefragment{ : \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst.\allowbreak{}s}}}\\
35
35
\end{ocamlindent}%
36
36
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
37
37
\end{ocamlindent}%
···
42
42
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
43
43
\end{ocamlindent}%
44
44
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
45
-
\label{Module_type_subst-Nested--module-type-with_}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Nested-module-type-with_]{\ocamlinlinecode{with\_\allowbreak{}}}}\label{Module_type_subst-Nested-module-type-with_}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Nested-module-type-with_--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Nested-module-type-with_-N]{\ocamlinlinecode{N}}}\label{Module_type_subst-Nested-module-type-with_-N}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Nested-module-type-with_-N--module-type-t}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} t = \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{s}}}\\
45
+
\label{Module_type_subst-Nested--module-type-with_}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Module_type_subst-Nested-module-type-with_]{\ocamlinlinecode{with\_\allowbreak{}}}}\label{Module_type_subst-Nested-module-type-with_}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Nested-module-type-with_--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Module_type_subst-Nested-module-type-with_-N]{\ocamlinlinecode{N}}}\label{Module_type_subst-Nested-module-type-with_-N}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Module_type_subst-Nested-module-type-with_-N--module-type-t}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} t = \hyperref[Module_type_subst-module-type-s]{\ocamlinlinecode{Module\_\allowbreak{}type\_\allowbreak{}subst.\allowbreak{}s}}}\\
46
46
\end{ocamlindent}%
47
47
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
48
48
\end{ocamlindent}%
+1
-1
odoc/test/generators/latex/Nested.F.tex
+1
-1
odoc/test/generators/latex/Nested.F.tex
···
8
8
\label{Nested-F-argument-1-Arg1--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\begin{ocamlindent}Some type.\end{ocamlindent}%
9
9
\medbreak
10
10
\subsubsection{Values\label{Nested-F-argument-1-Arg1--values}}%
11
-
\label{Nested-F-argument-1-Arg1--val-y}\ocamlcodefragment{\ocamltag{keyword}{val} y : \hyperref[Nested-F-argument-1-Arg1--type-t]{\ocamlinlinecode{t}}}\begin{ocamlindent}The value of y.\end{ocamlindent}%
11
+
\label{Nested-F-argument-1-Arg1--val-y}\ocamlcodefragment{\ocamltag{keyword}{val} y : \hyperref[Nested-F-argument-1-Arg1--type-t]{\ocamlinlinecode{Arg1.\allowbreak{}t}}}\begin{ocamlindent}The value of y.\end{ocamlindent}%
12
12
\medbreak
13
13
\end{ocamlindent}%
14
14
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
+2
-2
odoc/test/generators/latex/Nested.tex
+2
-2
odoc/test/generators/latex/Nested.tex
···
6
6
\label{Nested-X--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\begin{ocamlindent}Some type.\end{ocamlindent}%
7
7
\medbreak
8
8
\subsubsection{Values\label{Nested-X--values}}%
9
-
\label{Nested-X--val-x}\ocamlcodefragment{\ocamltag{keyword}{val} x : \hyperref[Nested-X--type-t]{\ocamlinlinecode{t}}}\begin{ocamlindent}The value of x.\end{ocamlindent}%
9
+
\label{Nested-X--val-x}\ocamlcodefragment{\ocamltag{keyword}{val} x : \hyperref[Nested-X--type-t]{\ocamlinlinecode{Nested.\allowbreak{}X.\allowbreak{}t}}}\begin{ocamlindent}The value of x.\end{ocamlindent}%
10
10
\medbreak
11
11
\end{ocamlindent}%
12
12
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This is module X.\end{ocamlindent}%
···
22
22
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This is module type Y.\end{ocamlindent}%
23
23
\medbreak
24
24
\subsection{Functor\label{Nested--functor}}%
25
-
\label{Nested--module-F}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Nested-F]{\ocamlinlinecode{F}}}\ocamlcodefragment{ (\hyperref[Nested-F-argument-1-Arg1]{\ocamlinlinecode{Arg1}} : \hyperref[Nested-module-type-Y]{\ocamlinlinecode{Y}}) (\hyperref[Nested-F-argument-2-Arg2]{\ocamlinlinecode{Arg2}} : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\begin{ocamlindent}This is a functor F.\end{ocamlindent}%
25
+
\label{Nested--module-F}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Nested-F]{\ocamlinlinecode{F}}}\ocamlcodefragment{ (\hyperref[Nested-F-argument-1-Arg1]{\ocamlinlinecode{Arg1}} : \hyperref[Nested-module-type-Y]{\ocamlinlinecode{Nested.\allowbreak{}Y}}) (\hyperref[Nested-F-argument-2-Arg2]{\ocamlinlinecode{Arg2}} : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\begin{ocamlindent}This is a functor F.\end{ocamlindent}%
26
26
\medbreak
27
27
\subsection{Class\label{Nested--class}}%
28
28
\label{Nested--class-z}\ocamlcodefragment{\ocamltag{keyword}{class} \ocamltag{keyword}{virtual} \hyperref[Nested-class-z]{\ocamlinlinecode{z}}}\ocamlcodefragment{ : \ocamltag{keyword}{object} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\begin{ocamlindent}This is class z.\end{ocamlindent}%
+1
-1
odoc/test/generators/latex/Ocamlary.Dep2.tex
+1
-1
odoc/test/generators/latex/Ocamlary.Dep2.tex
···
1
1
\section{Module \ocamlinlinecode{Ocamlary.\allowbreak{}Dep2}}\label{Ocamlary-Dep2}%
2
2
\subsection{Parameters\label{Ocamlary-Dep2--parameters}}%
3
3
\label{Ocamlary-Dep2--argument-1-Arg}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep2-argument-1-Arg]{\ocamlinlinecode{Arg}}}\label{Ocamlary-Dep2-argument-1-Arg}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep2-argument-1-Arg--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S}\\
4
-
\label{Ocamlary-Dep2-argument-1-Arg--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep2-argument-1-Arg-X]{\ocamlinlinecode{X}}}\label{Ocamlary-Dep2-argument-1-Arg-X}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep2-argument-1-Arg-X--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y : \hyperref[Ocamlary-Dep2-argument-1-Arg--module-type-S]{\ocamlinlinecode{S}}}\\
4
+
\label{Ocamlary-Dep2-argument-1-Arg--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep2-argument-1-Arg-X]{\ocamlinlinecode{X}}}\label{Ocamlary-Dep2-argument-1-Arg-X}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep2-argument-1-Arg-X--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y : \hyperref[Ocamlary-Dep2-argument-1-Arg--module-type-S]{\ocamlinlinecode{Arg.\allowbreak{}S}}}\\
5
5
\end{ocamlindent}%
6
6
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
7
7
\end{ocamlindent}%
+1
-1
odoc/test/generators/latex/Ocamlary.Dep5.Z.tex
+1
-1
odoc/test/generators/latex/Ocamlary.Dep5.Z.tex
···
1
1
\section{Module \ocamlinlinecode{Dep5.\allowbreak{}Z}}\label{Ocamlary-Dep5-Z}%
2
2
\label{Ocamlary-Dep5-Z--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} X : \hyperref[Ocamlary-Dep5-argument-1-Arg--module-type-T]{\ocamlinlinecode{Arg.\allowbreak{}T}}}\\
3
-
\label{Ocamlary-Dep5-Z--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y = \hyperref[Ocamlary-Dep3]{\ocamlinlinecode{Dep3}}}\\
3
+
\label{Ocamlary-Dep5-Z--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y = \hyperref[Ocamlary-Dep3]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep3}}}\\
4
4
5
5
+3
-3
odoc/test/generators/latex/Ocamlary.Dep5.tex
+3
-3
odoc/test/generators/latex/Ocamlary.Dep5.tex
···
1
1
\section{Module \ocamlinlinecode{Ocamlary.\allowbreak{}Dep5}}\label{Ocamlary-Dep5}%
2
2
\subsection{Parameters\label{Ocamlary-Dep5--parameters}}%
3
3
\label{Ocamlary-Dep5--argument-1-Arg}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5-argument-1-Arg]{\ocamlinlinecode{Arg}}}\label{Ocamlary-Dep5-argument-1-Arg}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep5-argument-1-Arg--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} T}\\
4
-
\label{Ocamlary-Dep5-argument-1-Arg--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-Dep5-argument-1-Arg-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep5-argument-1-Arg-module-type-S--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} X : \hyperref[Ocamlary-Dep5-argument-1-Arg--module-type-T]{\ocamlinlinecode{T}}}\\
4
+
\label{Ocamlary-Dep5-argument-1-Arg--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-Dep5-argument-1-Arg-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep5-argument-1-Arg-module-type-S--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} X : \hyperref[Ocamlary-Dep5-argument-1-Arg--module-type-T]{\ocamlinlinecode{Arg.\allowbreak{}T}}}\\
5
5
\label{Ocamlary-Dep5-argument-1-Arg-module-type-S--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S-Y]{\ocamlinlinecode{Y}}}\label{Ocamlary-Dep5-argument-1-Arg-module-type-S-Y}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
6
6
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
7
7
\end{ocamlindent}%
8
8
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
9
-
\label{Ocamlary-Dep5-argument-1-Arg--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} X : \hyperref[Ocamlary-Dep5-argument-1-Arg--module-type-T]{\ocamlinlinecode{T}}}\\
9
+
\label{Ocamlary-Dep5-argument-1-Arg--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} X : \hyperref[Ocamlary-Dep5-argument-1-Arg--module-type-T]{\ocamlinlinecode{Arg.\allowbreak{}T}}}\\
10
10
\end{ocamlindent}%
11
11
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
12
12
\subsection{Signature\label{Ocamlary-Dep5--signature}}%
13
-
\label{Ocamlary-Dep5--module-Z}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5-Z]{\ocamlinlinecode{Z}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S]{\ocamlinlinecode{Arg.\allowbreak{}S}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S-Y]{\ocamlinlinecode{Y}} = \hyperref[Ocamlary-Dep3]{\ocamlinlinecode{Dep3}}}\\
13
+
\label{Ocamlary-Dep5--module-Z}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5-Z]{\ocamlinlinecode{Z}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S]{\ocamlinlinecode{Arg.\allowbreak{}S}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5-argument-1-Arg-module-type-S-Y]{\ocamlinlinecode{Y}} = \hyperref[Ocamlary-Dep3]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep3}}}\\
14
14
15
15
\input{Ocamlary.Dep5.Z.tex}
+1
-1
odoc/test/generators/latex/Ocamlary.Dep7.M.tex
+1
-1
odoc/test/generators/latex/Ocamlary.Dep7.M.tex
···
1
1
\section{Module \ocamlinlinecode{Dep7.\allowbreak{}M}}\label{Ocamlary-Dep7-M}%
2
2
\label{Ocamlary-Dep7-M--module-type-R}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} R = \hyperref[Ocamlary-Dep7-argument-1-Arg--module-type-S]{\ocamlinlinecode{Arg.\allowbreak{}S}}}\\
3
-
\label{Ocamlary-Dep7-M--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y : \hyperref[Ocamlary-Dep7-argument-1-Arg--module-type-S]{\ocamlinlinecode{R}}}\\
3
+
\label{Ocamlary-Dep7-M--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y : \hyperref[Ocamlary-Dep7-argument-1-Arg--module-type-S]{\ocamlinlinecode{M.\allowbreak{}R}}}\\
4
4
5
5
+2
-2
odoc/test/generators/latex/Ocamlary.Dep7.tex
+2
-2
odoc/test/generators/latex/Ocamlary.Dep7.tex
···
1
1
\section{Module \ocamlinlinecode{Ocamlary.\allowbreak{}Dep7}}\label{Ocamlary-Dep7}%
2
2
\subsection{Parameters\label{Ocamlary-Dep7--parameters}}%
3
3
\label{Ocamlary-Dep7--argument-1-Arg}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep7-argument-1-Arg]{\ocamlinlinecode{Arg}}}\label{Ocamlary-Dep7-argument-1-Arg}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep7-argument-1-Arg--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S}\\
4
-
\label{Ocamlary-Dep7-argument-1-Arg--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep7-argument-1-Arg-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-Dep7-argument-1-Arg-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep7-argument-1-Arg-module-type-T--module-type-R}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} R = \hyperref[Ocamlary-Dep7-argument-1-Arg--module-type-S]{\ocamlinlinecode{S}}}\\
4
+
\label{Ocamlary-Dep7-argument-1-Arg--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep7-argument-1-Arg-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-Dep7-argument-1-Arg-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep7-argument-1-Arg-module-type-T--module-type-R}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} R = \hyperref[Ocamlary-Dep7-argument-1-Arg--module-type-S]{\ocamlinlinecode{Arg.\allowbreak{}S}}}\\
5
5
\label{Ocamlary-Dep7-argument-1-Arg-module-type-T--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} Y : \hyperref[Ocamlary-Dep7-argument-1-Arg--module-type-S]{\ocamlinlinecode{R}}}\\
6
6
\end{ocamlindent}%
7
7
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
8
-
\label{Ocamlary-Dep7-argument-1-Arg--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep7-argument-1-Arg-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep7-argument-1-Arg-module-type-T]{\ocamlinlinecode{T}}}\\
8
+
\label{Ocamlary-Dep7-argument-1-Arg--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep7-argument-1-Arg-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep7-argument-1-Arg-module-type-T]{\ocamlinlinecode{Arg.\allowbreak{}T}}}\\
9
9
\end{ocamlindent}%
10
10
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
11
11
\subsection{Signature\label{Ocamlary-Dep7--signature}}%
+4
-4
odoc/test/generators/latex/Ocamlary.FunctorTypeOf.tex
+4
-4
odoc/test/generators/latex/Ocamlary.FunctorTypeOf.tex
···
5
5
\label{Ocamlary-FunctorTypeOf--argument-1-Collection}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection]{\ocamlinlinecode{Collection}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection--type-collection}\ocamlcodefragment{\ocamltag{keyword}{type} collection}\begin{ocamlindent}This comment is for \ocamlinlinecode{collection}.\end{ocamlindent}%
6
6
\medbreak
7
7
\label{Ocamlary-FunctorTypeOf-argument-1-Collection--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element}\\
8
-
\label{Ocamlary-FunctorTypeOf-argument-1-Collection--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection--type-collection]{\ocamlinlinecode{collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
8
+
\label{Ocamlary-FunctorTypeOf-argument-1-Collection--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection--type-collection]{\ocamlinlinecode{Collection.\allowbreak{}collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
9
9
\medbreak
10
-
\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
10
+
\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
11
11
\medbreak
12
12
\end{ocamlindent}%
13
13
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA'}.\end{ocamlindent}%
14
14
\medbreak
15
-
\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
15
+
\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{Collection.\allowbreak{}InnerModuleA.\allowbreak{}InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
16
16
\medbreak
17
17
\end{ocamlindent}%
18
18
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA'}.\end{ocamlindent}%
···
20
20
\end{ocamlindent}%
21
21
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA}.\end{ocamlindent}%
22
22
\medbreak
23
-
\label{Ocamlary-FunctorTypeOf-argument-1-Collection--module-type-InnerModuleTypeA}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} InnerModuleTypeA = \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleA.\allowbreak{}InnerModuleTypeA'}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA}.\end{ocamlindent}%
23
+
\label{Ocamlary-FunctorTypeOf-argument-1-Collection--module-type-InnerModuleTypeA}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} InnerModuleTypeA = \hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{Collection.\allowbreak{}InnerModuleA.\allowbreak{}InnerModuleTypeA'}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA}.\end{ocamlindent}%
24
24
\medbreak
25
25
\end{ocamlindent}%
26
26
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
+6
-6
odoc/test/generators/latex/Ocamlary.Recollection.tex
+6
-6
odoc/test/generators/latex/Ocamlary.Recollection.tex
···
5
5
\label{Ocamlary-Recollection--argument-1-C}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-argument-1-C]{\ocamlinlinecode{C}}}\label{Ocamlary-Recollection-argument-1-C}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C--type-collection}\ocamlcodefragment{\ocamltag{keyword}{type} collection}\begin{ocamlindent}This comment is for \ocamlinlinecode{collection}.\end{ocamlindent}%
6
6
\medbreak
7
7
\label{Ocamlary-Recollection-argument-1-C--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element}\\
8
-
\label{Ocamlary-Recollection-argument-1-C--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection-argument-1-C--type-collection]{\ocamlinlinecode{collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
8
+
\label{Ocamlary-Recollection-argument-1-C--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection-argument-1-C--type-collection]{\ocamlinlinecode{C.\allowbreak{}collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
9
9
\medbreak
10
-
\label{Ocamlary-Recollection-argument-1-C-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
10
+
\label{Ocamlary-Recollection-argument-1-C-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
11
11
\medbreak
12
12
\end{ocamlindent}%
13
13
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA'}.\end{ocamlindent}%
14
14
\medbreak
15
-
\label{Ocamlary-Recollection-argument-1-C-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
15
+
\label{Ocamlary-Recollection-argument-1-C-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{C.\allowbreak{}InnerModuleA.\allowbreak{}InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
16
16
\medbreak
17
17
\end{ocamlindent}%
18
18
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA'}.\end{ocamlindent}%
···
20
20
\end{ocamlindent}%
21
21
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA}.\end{ocamlindent}%
22
22
\medbreak
23
-
\label{Ocamlary-Recollection-argument-1-C--module-type-InnerModuleTypeA}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} InnerModuleTypeA = \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleA.\allowbreak{}InnerModuleTypeA'}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA}.\end{ocamlindent}%
23
+
\label{Ocamlary-Recollection-argument-1-C--module-type-InnerModuleTypeA}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} InnerModuleTypeA = \hyperref[Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{C.\allowbreak{}InnerModuleA.\allowbreak{}InnerModuleTypeA'}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA}.\end{ocamlindent}%
24
24
\medbreak
25
25
\end{ocamlindent}%
26
26
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
···
30
30
\label{Ocamlary-Recollection--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element = \hyperref[Ocamlary-Recollection-argument-1-C--type-collection]{\ocamlinlinecode{C.\allowbreak{}collection}}}\\
31
31
\label{Ocamlary-Recollection--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-Recollection-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection--type-collection]{\ocamlinlinecode{collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
32
32
\medbreak
33
-
\label{Ocamlary-Recollection-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-Recollection-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
33
+
\label{Ocamlary-Recollection-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-Recollection-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
34
34
\medbreak
35
35
\end{ocamlindent}%
36
36
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA'}.\end{ocamlindent}%
37
37
\medbreak
38
-
\label{Ocamlary-Recollection-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
38
+
\label{Ocamlary-Recollection-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-Recollection-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA.\allowbreak{}InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
39
39
\medbreak
40
40
\end{ocamlindent}%
41
41
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA'}.\end{ocamlindent}%
+1
-1
odoc/test/generators/latex/Ocamlary.With3.tex
+1
-1
odoc/test/generators/latex/Ocamlary.With3.tex
···
1
1
\section{Module \ocamlinlinecode{Ocamlary.\allowbreak{}With3}}\label{Ocamlary-With3}%
2
-
\label{Ocamlary-With3--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Ocamlary-With2]{\ocamlinlinecode{With2}}}\\
2
+
\label{Ocamlary-With3--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Ocamlary-With2]{\ocamlinlinecode{Ocamlary.\allowbreak{}With2}}}\\
3
3
\label{Ocamlary-With3--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With3-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \hyperref[Ocamlary-With2-module-type-S]{\ocamlinlinecode{M.\allowbreak{}S}}}\\
4
4
5
5
\input{Ocamlary.With3.N.tex}
+1
-1
odoc/test/generators/latex/Ocamlary.With4.tex
+1
-1
odoc/test/generators/latex/Ocamlary.With4.tex
···
1
1
\section{Module \ocamlinlinecode{Ocamlary.\allowbreak{}With4}}\label{Ocamlary-With4}%
2
-
\label{Ocamlary-With4--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With4-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \hyperref[Ocamlary-With2--module-type-S]{\ocamlinlinecode{With2.\allowbreak{}S}}}\\
2
+
\label{Ocamlary-With4--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With4-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \hyperref[Ocamlary-With2--module-type-S]{\ocamlinlinecode{Ocamlary.\allowbreak{}With2.\allowbreak{}S}}}\\
3
3
4
4
\input{Ocamlary.With4.N.tex}
+117
-104
odoc/test/generators/latex/Ocamlary.tex
+117
-104
odoc/test/generators/latex/Ocamlary.tex
···
68
68
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}An ambiguous, misnamed module type\end{ocamlindent}%
69
69
\medbreak
70
70
\subsection{Section 9000\label{Ocamlary--s9000}}%
71
-
\label{Ocamlary--module-EmptyAlias}\ocamlcodefragment{\ocamltag{keyword}{module} EmptyAlias = \hyperref[Ocamlary-Empty]{\ocamlinlinecode{Empty}}}\begin{ocamlindent}A plain module alias of \ocamlinlinecode{Empty}\end{ocamlindent}%
71
+
\label{Ocamlary--module-EmptyAlias}\ocamlcodefragment{\ocamltag{keyword}{module} EmptyAlias = \hyperref[Ocamlary-Empty]{\ocamlinlinecode{Ocamlary.\allowbreak{}Empty}}}\begin{ocamlindent}A plain module alias of \ocamlinlinecode{Empty}\end{ocamlindent}%
72
72
\medbreak
73
73
\subsubsection{EmptySig\label{Ocamlary--emptySig}}%
74
74
\label{Ocamlary--module-type-EmptySig}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{EmptySig}}}\label{Ocamlary-module-type-EmptySig}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
75
75
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}A plain, empty module signature\end{ocamlindent}%
76
76
\medbreak
77
-
\label{Ocamlary--module-type-EmptySigAlias}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} EmptySigAlias = \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{EmptySig}}}\begin{ocamlindent}A plain, empty module signature alias of\end{ocamlindent}%
77
+
\label{Ocamlary--module-type-EmptySigAlias}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} EmptySigAlias = \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{Ocamlary.\allowbreak{}EmptySig}}}\begin{ocamlindent}A plain, empty module signature alias of\end{ocamlindent}%
78
78
\medbreak
79
-
\label{Ocamlary--module-ModuleWithSignature}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-ModuleWithSignature]{\ocamlinlinecode{ModuleWithSignature}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{EmptySig}}}\begin{ocamlindent}A plain module of a signature of \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{\ocamlinlinecode{EmptySig}}[p\pageref*{Ocamlary-module-type-EmptySig}]} (reference)\end{ocamlindent}%
79
+
\label{Ocamlary--module-ModuleWithSignature}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-ModuleWithSignature]{\ocamlinlinecode{ModuleWithSignature}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{Ocamlary.\allowbreak{}EmptySig}}}\begin{ocamlindent}A plain module of a signature of \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{\ocamlinlinecode{EmptySig}}[p\pageref*{Ocamlary-module-type-EmptySig}]} (reference)\end{ocamlindent}%
80
80
\medbreak
81
-
\label{Ocamlary--module-ModuleWithSignatureAlias}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-ModuleWithSignatureAlias]{\ocamlinlinecode{ModuleWithSignatureAlias}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{EmptySigAlias}}}\begin{ocamlindent}A plain module with an alias signature\end{ocamlindent}%
81
+
\label{Ocamlary--module-ModuleWithSignatureAlias}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-ModuleWithSignatureAlias]{\ocamlinlinecode{ModuleWithSignatureAlias}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{Ocamlary.\allowbreak{}EmptySigAlias}}}\begin{ocamlindent}A plain module with an alias signature\end{ocamlindent}%
82
82
\medbreak
83
83
\label{Ocamlary--module-One}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-One]{\ocamlinlinecode{One}}}\label{Ocamlary-One}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-One--type-one}\ocamlcodefragment{\ocamltag{keyword}{type} one}\\
84
84
\end{ocamlindent}%
···
143
143
\item[{returns}]{the \ocamlinlinecode{y} coordinate}\end{description}%
144
144
\end{ocamlindent}%
145
145
\medbreak
146
-
\label{Ocamlary--val-fun_fun_fun}\ocamlcodefragment{\ocamltag{keyword}{val} fun\_\allowbreak{}fun\_\allowbreak{}fun : ((int,\allowbreak{} int) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}},\allowbreak{} (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\\
146
+
\label{Ocamlary--val-fun_fun_fun}\ocamlcodefragment{\ocamltag{keyword}{val} fun\_\allowbreak{}fun\_\allowbreak{}fun :
147
+
((int,\allowbreak{} int) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}},\allowbreak{} (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}})
148
+
\hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\\
147
149
\label{Ocamlary--val-fun_maybe}\ocamlcodefragment{\ocamltag{keyword}{val} fun\_\allowbreak{}maybe : \ocamltag{optlabel}{?yes}:unit \ocamltag{arrow}{$\rightarrow$} unit \ocamltag{arrow}{$\rightarrow$} int}\\
148
150
\label{Ocamlary--val-not_found}\ocamlcodefragment{\ocamltag{keyword}{val} not\_\allowbreak{}found : unit \ocamltag{arrow}{$\rightarrow$} unit}\begin{ocamlindent}\begin{description}\kern-\topsep
149
151
\makeatletter\advance\@topsepadd-\topsep\makeatother% topsep is hardcoded
···
205
207
\label{Ocamlary--module-CollectionModule}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CollectionModule]{\ocamlinlinecode{CollectionModule}}}\label{Ocamlary-CollectionModule}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule--type-collection}\ocamlcodefragment{\ocamltag{keyword}{type} collection}\begin{ocamlindent}This comment is for \ocamlinlinecode{collection}.\end{ocamlindent}%
206
208
\medbreak
207
209
\label{Ocamlary-CollectionModule--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element}\\
208
-
\label{Ocamlary-CollectionModule--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CollectionModule-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-CollectionModule-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-CollectionModule--type-collection]{\ocamlinlinecode{collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
210
+
\label{Ocamlary-CollectionModule--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CollectionModule-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-CollectionModule-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-CollectionModule--type-collection]{\ocamlinlinecode{Ocamlary.\allowbreak{}CollectionModule.\allowbreak{}collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
209
211
\medbreak
210
-
\label{Ocamlary-CollectionModule-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CollectionModule-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
212
+
\label{Ocamlary-CollectionModule-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CollectionModule-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
211
213
\medbreak
212
214
\end{ocamlindent}%
213
215
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA'}.\end{ocamlindent}%
214
216
\medbreak
215
-
\label{Ocamlary-CollectionModule-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
217
+
\label{Ocamlary-CollectionModule-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}CollectionModule.\allowbreak{}InnerModuleA.\allowbreak{}InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
216
218
\medbreak
217
219
\end{ocamlindent}%
218
220
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA'}.\end{ocamlindent}%
···
220
222
\end{ocamlindent}%
221
223
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA}.\end{ocamlindent}%
222
224
\medbreak
223
-
\label{Ocamlary-CollectionModule--module-type-InnerModuleTypeA}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} InnerModuleTypeA = \hyperref[Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleA.\allowbreak{}InnerModuleTypeA'}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA}.\end{ocamlindent}%
225
+
\label{Ocamlary-CollectionModule--module-type-InnerModuleTypeA}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} InnerModuleTypeA =
226
+
\hyperref[Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{Ocamlary.\allowbreak{}CollectionModule.\allowbreak{}InnerModuleA.\allowbreak{}InnerModuleTypeA'}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA}.\end{ocamlindent}%
224
227
\medbreak
225
228
\end{ocamlindent}%
226
229
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
···
230
233
\label{Ocamlary-module-type-COLLECTION--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element}\\
231
234
\label{Ocamlary-module-type-COLLECTION--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-module-type-COLLECTION-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-COLLECTION-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-module-type-COLLECTION--type-collection]{\ocamlinlinecode{collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
232
235
\medbreak
233
-
\label{Ocamlary-module-type-COLLECTION-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
236
+
\label{Ocamlary-module-type-COLLECTION-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
234
237
\medbreak
235
238
\end{ocamlindent}%
236
239
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA'}.\end{ocamlindent}%
237
240
\medbreak
238
-
\label{Ocamlary-module-type-COLLECTION-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
241
+
\label{Ocamlary-module-type-COLLECTION-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA.\allowbreak{}InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
239
242
\medbreak
240
243
\end{ocamlindent}%
241
244
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA'}.\end{ocamlindent}%
···
249
252
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}module type of\end{ocamlindent}%
250
253
\medbreak
251
254
\label{Ocamlary--module-Recollection}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Recollection]{\ocamlinlinecode{Recollection}}}\ocamlcodefragment{
252
-
(\hyperref[Ocamlary-Recollection-argument-1-C]{\ocamlinlinecode{C}} : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}}) :
253
-
\hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}}
255
+
(\hyperref[Ocamlary-Recollection-argument-1-C]{\ocamlinlinecode{C}} : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}}) :
256
+
\hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}}
254
257
\ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-COLLECTION--type-collection]{\ocamlinlinecode{collection}} = \hyperref[Ocamlary-Recollection-argument-1-C--type-element]{\ocamlinlinecode{C.\allowbreak{}element}} list
255
258
\ocamltag{keyword}{and} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-COLLECTION--type-element]{\ocamlinlinecode{element}} = \hyperref[Ocamlary-Recollection-argument-1-C--type-collection]{\ocamlinlinecode{C.\allowbreak{}collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
256
259
\medbreak
257
-
\label{Ocamlary--module-type-MMM}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-MMM]{\ocamlinlinecode{MMM}}}\label{Ocamlary-module-type-MMM}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-MMM--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-MMM-C]{\ocamlinlinecode{C}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
260
+
\label{Ocamlary--module-type-MMM}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-MMM]{\ocamlinlinecode{MMM}}}\label{Ocamlary-module-type-MMM}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-MMM--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-MMM-C]{\ocamlinlinecode{C}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
258
261
\medbreak
259
262
\end{ocamlindent}%
260
263
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
261
-
\label{Ocamlary--module-type-RECOLLECTION}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-RECOLLECTION]{\ocamlinlinecode{RECOLLECTION}}}\label{Ocamlary-module-type-RECOLLECTION}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RECOLLECTION--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} C = \hyperref[Ocamlary-Recollection]{\ocamlinlinecode{Recollection(CollectionModule)}}}\\
264
+
\label{Ocamlary--module-type-RECOLLECTION}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-RECOLLECTION]{\ocamlinlinecode{RECOLLECTION}}}\label{Ocamlary-module-type-RECOLLECTION}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RECOLLECTION--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} C = \hyperref[Ocamlary-Recollection]{\ocamlinlinecode{Ocamlary.\allowbreak{}Recollection(Ocamlary.\allowbreak{}CollectionModule)}}}\\
262
265
\end{ocamlindent}%
263
266
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
264
-
\label{Ocamlary--module-type-RecollectionModule}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-RecollectionModule]{\ocamlinlinecode{RecollectionModule}}}\label{Ocamlary-module-type-RecollectionModule}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}\label{Ocamlary-module-type-RecollectionModule--type-collection}\ocamlcodefragment{\ocamltag{keyword}{type} collection = \hyperref[Ocamlary-CollectionModule--type-element]{\ocamlinlinecode{CollectionModule.\allowbreak{}element}} list}\\
265
-
\label{Ocamlary-module-type-RecollectionModule--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element = \hyperref[Ocamlary-CollectionModule--type-collection]{\ocamlinlinecode{CollectionModule.\allowbreak{}collection}}}\\
267
+
\label{Ocamlary--module-type-RecollectionModule}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-RecollectionModule]{\ocamlinlinecode{RecollectionModule}}}\label{Ocamlary-module-type-RecollectionModule}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}\label{Ocamlary-module-type-RecollectionModule--type-collection}\ocamlcodefragment{\ocamltag{keyword}{type} collection = \hyperref[Ocamlary-CollectionModule--type-element]{\ocamlinlinecode{Ocamlary.\allowbreak{}CollectionModule.\allowbreak{}element}} list}\\
268
+
\label{Ocamlary-module-type-RecollectionModule--type-element}\ocamlcodefragment{\ocamltag{keyword}{type} element = \hyperref[Ocamlary-CollectionModule--type-collection]{\ocamlinlinecode{Ocamlary.\allowbreak{}CollectionModule.\allowbreak{}collection}}}\\
266
269
\label{Ocamlary-module-type-RecollectionModule--module-InnerModuleA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA]{\ocamlinlinecode{InnerModuleA}}}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-module-type-RecollectionModule--type-collection]{\ocamlinlinecode{collection}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
267
270
\medbreak
268
-
\label{Ocamlary-module-type-RecollectionModule-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
271
+
\label{Ocamlary-module-type-RecollectionModule-InnerModuleA--module-InnerModuleA'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA']{\ocamlinlinecode{InnerModuleA'}}}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-a_function]{\ocamlinlinecode{Ocamlary.\allowbreak{}a\_\allowbreak{}function}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
269
272
\medbreak
270
273
\end{ocamlindent}%
271
274
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleA'}.\end{ocamlindent}%
272
275
\medbreak
273
-
\label{Ocamlary-module-type-RecollectionModule-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
276
+
\label{Ocamlary-module-type-RecollectionModule-InnerModuleA--module-type-InnerModuleTypeA'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA']{\ocamlinlinecode{InnerModuleTypeA'}}}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = \hyperref[Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'--type-t]{\ocamlinlinecode{InnerModuleA.\allowbreak{}InnerModuleA'.\allowbreak{}t}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{t}.\end{ocamlindent}%
274
277
\medbreak
275
278
\end{ocamlindent}%
276
279
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{InnerModuleTypeA'}.\end{ocamlindent}%
···
283
286
\end{ocamlindent}%
284
287
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
285
288
\label{Ocamlary--module-type-A}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-A]{\ocamlinlinecode{A}}}\label{Ocamlary-module-type-A}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-A--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
286
-
\label{Ocamlary-module-type-A--module-Q}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-A-Q]{\ocamlinlinecode{Q}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
289
+
\label{Ocamlary-module-type-A--module-Q}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-A-Q]{\ocamlinlinecode{Q}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
287
290
\medbreak
288
291
\end{ocamlindent}%
289
292
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
290
293
\label{Ocamlary--module-type-B}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-B]{\ocamlinlinecode{B}}}\label{Ocamlary-module-type-B}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-B--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
291
-
\label{Ocamlary-module-type-B--module-Q}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-B-Q]{\ocamlinlinecode{Q}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
294
+
\label{Ocamlary-module-type-B--module-Q}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-B-Q]{\ocamlinlinecode{Q}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
292
295
\medbreak
293
296
\end{ocamlindent}%
294
297
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
295
-
\label{Ocamlary--module-type-C}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-C]{\ocamlinlinecode{C}}}\label{Ocamlary-module-type-C}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-A]{\ocamlinlinecode{A}}\label{Ocamlary-module-type-C--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
296
-
\label{Ocamlary-module-type-C--module-Q}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-C-Q]{\ocamlinlinecode{Q}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
298
+
\label{Ocamlary--module-type-C}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-C]{\ocamlinlinecode{C}}}\label{Ocamlary-module-type-C}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-A]{\ocamlinlinecode{Ocamlary.\allowbreak{}A}}\label{Ocamlary-module-type-C--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
299
+
\label{Ocamlary-module-type-C--module-Q}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-C-Q]{\ocamlinlinecode{Q}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{CollectionModule}.\end{ocamlindent}%
297
300
\medbreak
298
-
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-B]{\ocamlinlinecode{B}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-B--type-t]{\ocamlinlinecode{t}} := \hyperref[Ocamlary-module-type-C--type-t]{\ocamlinlinecode{t}} \ocamltag{keyword}{and} \ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-B-Q]{\ocamlinlinecode{Q}} := \hyperref[Ocamlary-module-type-C-Q]{\ocamlinlinecode{Q}}\end{ocamlindent}%
301
+
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-B]{\ocamlinlinecode{Ocamlary.\allowbreak{}B}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-B--type-t]{\ocamlinlinecode{t}} := \hyperref[Ocamlary-module-type-C--type-t]{\ocamlinlinecode{t}} \ocamltag{keyword}{and} \ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-B-Q]{\ocamlinlinecode{Q}} := \hyperref[Ocamlary-module-type-C-Q]{\ocamlinlinecode{Q}}\end{ocamlindent}%
299
302
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This module type includes two signatures.\end{ocamlindent}%
300
303
\medbreak
301
304
\label{Ocamlary--module-FunctorTypeOf}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-FunctorTypeOf]{\ocamlinlinecode{FunctorTypeOf}}}\ocamlcodefragment{
302
-
(\hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection]{\ocamlinlinecode{Collection}} : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-CollectionModule]{\ocamlinlinecode{CollectionModule}}) :
305
+
(\hyperref[Ocamlary-FunctorTypeOf-argument-1-Collection]{\ocamlinlinecode{Collection}} : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-CollectionModule]{\ocamlinlinecode{Ocamlary.\allowbreak{}CollectionModule}}) :
303
306
\ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{FunctorTypeOf}.\end{ocamlindent}%
304
307
\medbreak
305
-
\label{Ocamlary--module-type-IncludeModuleType}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-IncludeModuleType]{\ocamlinlinecode{IncludeModuleType}}}\label{Ocamlary-module-type-IncludeModuleType}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}This comment is for \ocamlinlinecode{include EmptySigAlias}.\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{EmptySigAlias}}\end{ocamlindent}%
308
+
\label{Ocamlary--module-type-IncludeModuleType}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-IncludeModuleType]{\ocamlinlinecode{IncludeModuleType}}}\label{Ocamlary-module-type-IncludeModuleType}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}This comment is for \ocamlinlinecode{include EmptySigAlias}.\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-EmptySig]{\ocamlinlinecode{Ocamlary.\allowbreak{}EmptySigAlias}}\end{ocamlindent}%
306
309
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}This comment is for \ocamlinlinecode{IncludeModuleType}.\end{ocamlindent}%
307
310
\medbreak
308
311
\label{Ocamlary--module-type-ToInclude}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-ToInclude]{\ocamlinlinecode{ToInclude}}}\label{Ocamlary-module-type-ToInclude}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-ToInclude--module-IncludedA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-ToInclude-IncludedA]{\ocamlinlinecode{IncludedA}}}\label{Ocamlary-module-type-ToInclude-IncludedA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-ToInclude-IncludedA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
···
313
316
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
314
317
\end{ocamlindent}%
315
318
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
316
-
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-ToInclude]{\ocamlinlinecode{ToInclude}}\label{Ocamlary--module-IncludedA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-IncludedA]{\ocamlinlinecode{IncludedA}}}\label{Ocamlary-IncludedA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-IncludedA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
319
+
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-ToInclude]{\ocamlinlinecode{Ocamlary.\allowbreak{}ToInclude}}\label{Ocamlary--module-IncludedA}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-IncludedA]{\ocamlinlinecode{IncludedA}}}\label{Ocamlary-IncludedA}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-IncludedA--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
317
320
\end{ocamlindent}%
318
321
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
319
322
\label{Ocamlary--module-type-IncludedB}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-IncludedB]{\ocamlinlinecode{IncludedB}}}\label{Ocamlary-module-type-IncludedB}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-IncludedB--type-s}\ocamlcodefragment{\ocamltag{keyword}{type} s}\\
···
356
359
\ocamlcodefragment{ ]}\begin{ocamlindent}This comment is for \ocamlinlinecode{poly\_\allowbreak{}variant}.Wow! It was a polymorphic variant!\end{ocamlindent}%
357
360
\medbreak
358
361
\label{Ocamlary--type-full_gadt}\ocamlcodefragment{\ocamltag{keyword}{type} (\_\allowbreak{},\allowbreak{} \_\allowbreak{}) full\_\allowbreak{}gadt = }\\
359
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Tag} : (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.Tag}\\
360
-
\ocamlcodefragment{| \ocamltag{constructor}{First} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'a},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.First}\\
361
-
\ocamlcodefragment{| \ocamltag{constructor}{Second} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (unit,\allowbreak{} \ocamltag{type-var}{'a}) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.Second}\\
362
-
\ocamlcodefragment{| \ocamltag{constructor}{Exist} : \ocamltag{type-var}{'a} * \ocamltag{type-var}{'b} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'b},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.Exist}\\
362
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Tag} : (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.Tag}\\
363
+
\ocamlcodefragment{| \ocamltag{constructor}{First} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'a},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.First}\\
364
+
\ocamlcodefragment{| \ocamltag{constructor}{Second} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (unit,\allowbreak{} \ocamltag{type-var}{'a}) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.Second}\\
365
+
\ocamlcodefragment{| \ocamltag{constructor}{Exist} : \ocamltag{type-var}{'a} * \ocamltag{type-var}{'b} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'b},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt}}}\label{Ocamlary--type-full_gadt.Exist}\\
363
366
\end{ocamltabular}%
364
367
\\
365
368
\begin{ocamlindent}This comment is for \ocamlinlinecode{full\_\allowbreak{}gadt}.Wow! It was a GADT!\end{ocamlindent}%
366
369
\medbreak
367
370
\label{Ocamlary--type-partial_gadt}\ocamlcodefragment{\ocamltag{keyword}{type} 'a partial\_\allowbreak{}gadt = }\\
368
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{AscribeTag} : \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{partial\_\allowbreak{}gadt}}}\label{Ocamlary--type-partial_gadt.AscribeTag}\\
369
-
\ocamlcodefragment{| \ocamltag{constructor}{OfTag} \ocamltag{keyword}{of} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{partial\_\allowbreak{}gadt}}}\label{Ocamlary--type-partial_gadt.OfTag}\\
370
-
\ocamlcodefragment{| \ocamltag{constructor}{ExistGadtTag} : (\ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'b}) \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{partial\_\allowbreak{}gadt}}}\label{Ocamlary--type-partial_gadt.ExistGadtTag}\\
371
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{AscribeTag} : \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt}}}\label{Ocamlary--type-partial_gadt.AscribeTag}\\
372
+
\ocamlcodefragment{| \ocamltag{constructor}{OfTag} \ocamltag{keyword}{of} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt}}}\label{Ocamlary--type-partial_gadt.OfTag}\\
373
+
\ocamlcodefragment{| \ocamltag{constructor}{ExistGadtTag} : (\ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'b}) \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt}}}\label{Ocamlary--type-partial_gadt.ExistGadtTag}\\
371
374
\end{ocamltabular}%
372
375
\\
373
376
\begin{ocamlindent}This comment is for \ocamlinlinecode{partial\_\allowbreak{}gadt}.Wow! It was a mixed GADT!\end{ocamlindent}%
374
377
\medbreak
375
-
\label{Ocamlary--type-alias}\ocamlcodefragment{\ocamltag{keyword}{type} alias = \hyperref[Ocamlary--type-variant]{\ocamlinlinecode{variant}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{alias}.\end{ocamlindent}%
378
+
\label{Ocamlary--type-alias}\ocamlcodefragment{\ocamltag{keyword}{type} alias = \hyperref[Ocamlary--type-variant]{\ocamlinlinecode{Ocamlary.\allowbreak{}variant}}}\begin{ocamlindent}This comment is for \ocamlinlinecode{alias}.\end{ocamlindent}%
376
379
\medbreak
377
-
\label{Ocamlary--type-tuple}\ocamlcodefragment{\ocamltag{keyword}{type} tuple = (\hyperref[Ocamlary--type-alias]{\ocamlinlinecode{alias}} * \hyperref[Ocamlary--type-alias]{\ocamlinlinecode{alias}}) * \hyperref[Ocamlary--type-alias]{\ocamlinlinecode{alias}} * (\hyperref[Ocamlary--type-alias]{\ocamlinlinecode{alias}} * \hyperref[Ocamlary--type-alias]{\ocamlinlinecode{alias}})}\begin{ocamlindent}This comment is for \ocamlinlinecode{tuple}.\end{ocamlindent}%
380
+
\label{Ocamlary--type-tuple}\ocamlcodefragment{\ocamltag{keyword}{type} tuple =
381
+
(\hyperref[Ocamlary--type-alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}alias}} * \hyperref[Ocamlary--type-alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}alias}})
382
+
* \hyperref[Ocamlary--type-alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}alias}}
383
+
* (\hyperref[Ocamlary--type-alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}alias}} * \hyperref[Ocamlary--type-alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}alias}})}\begin{ocamlindent}This comment is for \ocamlinlinecode{tuple}.\end{ocamlindent}%
378
384
\medbreak
379
-
\label{Ocamlary--type-variant_alias}\ocamlcodefragment{\ocamltag{keyword}{type} variant\_\allowbreak{}alias = \hyperref[Ocamlary--type-variant]{\ocamlinlinecode{variant}} = }\\
385
+
\label{Ocamlary--type-variant_alias}\ocamlcodefragment{\ocamltag{keyword}{type} variant\_\allowbreak{}alias = \hyperref[Ocamlary--type-variant]{\ocamlinlinecode{Ocamlary.\allowbreak{}variant}} = }\\
380
386
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{TagA}}\label{Ocamlary--type-variant_alias.TagA}\\
381
387
\ocamlcodefragment{| \ocamltag{constructor}{ConstrB} \ocamltag{keyword}{of} int}\label{Ocamlary--type-variant_alias.ConstrB}\\
382
388
\ocamlcodefragment{| \ocamltag{constructor}{ConstrC} \ocamltag{keyword}{of} int * int}\label{Ocamlary--type-variant_alias.ConstrC}\\
···
385
391
\\
386
392
\begin{ocamlindent}This comment is for \ocamlinlinecode{variant\_\allowbreak{}alias}.\end{ocamlindent}%
387
393
\medbreak
388
-
\label{Ocamlary--type-record_alias}\ocamlcodefragment{\ocamltag{keyword}{type} record\_\allowbreak{}alias = \hyperref[Ocamlary--type-record]{\ocamlinlinecode{record}} = \{}\\
394
+
\label{Ocamlary--type-record_alias}\ocamlcodefragment{\ocamltag{keyword}{type} record\_\allowbreak{}alias = \hyperref[Ocamlary--type-record]{\ocamlinlinecode{Ocamlary.\allowbreak{}record}} = \{}\\
389
395
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{field1 : int;\allowbreak{}}\label{Ocamlary--type-record_alias.field1}\\
390
396
\ocamlinlinecode{field2 : int;\allowbreak{}}\label{Ocamlary--type-record_alias.field2}\\
391
397
\end{ocamltabular}%
···
393
399
\ocamlcodefragment{\}}\begin{ocamlindent}This comment is for \ocamlinlinecode{record\_\allowbreak{}alias}.\end{ocamlindent}%
394
400
\medbreak
395
401
\label{Ocamlary--type-poly_variant_union}\ocamlcodefragment{\ocamltag{keyword}{type} poly\_\allowbreak{}variant\_\allowbreak{}union = [ }\\
396
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \hyperref[Ocamlary--type-poly_variant]{\ocamlinlinecode{poly\_\allowbreak{}variant}}}\label{Ocamlary--type-poly_variant_union.poly_variant}\\
402
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \hyperref[Ocamlary--type-poly_variant]{\ocamlinlinecode{Ocamlary.\allowbreak{}poly\_\allowbreak{}variant}}}\label{Ocamlary--type-poly_variant_union.Ocamlary.poly_variant}\\
397
403
\ocamlcodefragment{| `TagC}\label{Ocamlary--type-poly_variant_union.TagC}\\
398
404
\end{ocamltabular}%
399
405
\\
···
412
418
\ocamlcodefragment{ ]}\\
413
419
\label{Ocamlary--type-open_poly_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a open\_\allowbreak{}poly\_\allowbreak{}variant = [> `TagA ] \ocamltag{keyword}{as} 'a}\\
414
420
\label{Ocamlary--type-open_poly_variant2}\ocamlcodefragment{\ocamltag{keyword}{type} 'a open\_\allowbreak{}poly\_\allowbreak{}variant2 = [> `ConstrB of int ] \ocamltag{keyword}{as} 'a}\\
415
-
\label{Ocamlary--type-open_poly_variant_alias}\ocamlcodefragment{\ocamltag{keyword}{type} 'a open\_\allowbreak{}poly\_\allowbreak{}variant\_\allowbreak{}alias = \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-open_poly_variant]{\ocamlinlinecode{open\_\allowbreak{}poly\_\allowbreak{}variant}} \hyperref[Ocamlary--type-open_poly_variant2]{\ocamlinlinecode{open\_\allowbreak{}poly\_\allowbreak{}variant2}}}\\
421
+
\label{Ocamlary--type-open_poly_variant_alias}\ocamlcodefragment{\ocamltag{keyword}{type} 'a open\_\allowbreak{}poly\_\allowbreak{}variant\_\allowbreak{}alias =
422
+
\ocamltag{type-var}{'a} \hyperref[Ocamlary--type-open_poly_variant]{\ocamlinlinecode{Ocamlary.\allowbreak{}open\_\allowbreak{}poly\_\allowbreak{}variant}} \hyperref[Ocamlary--type-open_poly_variant2]{\ocamlinlinecode{Ocamlary.\allowbreak{}open\_\allowbreak{}poly\_\allowbreak{}variant2}}}\\
416
423
\label{Ocamlary--type-poly_fun}\ocamlcodefragment{\ocamltag{keyword}{type} 'a poly\_\allowbreak{}fun = ([> `ConstrB of int ] \ocamltag{keyword}{as} 'a) \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a}}\\
417
424
\label{Ocamlary--type-poly_fun_constraint}\ocamlcodefragment{\ocamltag{keyword}{type} 'a poly\_\allowbreak{}fun\_\allowbreak{}constraint = \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [> `TagA ]}\\
418
425
\label{Ocamlary--type-closed_poly_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a closed\_\allowbreak{}poly\_\allowbreak{}variant = [< `One | `Two ] \ocamltag{keyword}{as} 'a}\\
···
425
432
\end{ocamltabular}%
426
433
\\
427
434
\ocamlcodefragment{ ]}\\
428
-
\label{Ocamlary--type-full_gadt_alias}\ocamlcodefragment{\ocamltag{keyword}{type} ('a,\allowbreak{} 'b) full\_\allowbreak{}gadt\_\allowbreak{}alias = (\ocamltag{type-var}{'a},\allowbreak{} \ocamltag{type-var}{'b}) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{full\_\allowbreak{}gadt}} = }\\
429
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Tag} : (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.Tag}\\
430
-
\ocamlcodefragment{| \ocamltag{constructor}{First} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'a},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.First}\\
431
-
\ocamlcodefragment{| \ocamltag{constructor}{Second} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (unit,\allowbreak{} \ocamltag{type-var}{'a}) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.Second}\\
432
-
\ocamlcodefragment{| \ocamltag{constructor}{Exist} : \ocamltag{type-var}{'a} * \ocamltag{type-var}{'b} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'b},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.Exist}\\
435
+
\label{Ocamlary--type-full_gadt_alias}\ocamlcodefragment{\ocamltag{keyword}{type} ('a,\allowbreak{} 'b) full\_\allowbreak{}gadt\_\allowbreak{}alias = (\ocamltag{type-var}{'a},\allowbreak{} \ocamltag{type-var}{'b}) \hyperref[Ocamlary--type-full_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt}} = }\\
436
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Tag} : (unit,\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.Tag}\\
437
+
\ocamlcodefragment{| \ocamltag{constructor}{First} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'a},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.First}\\
438
+
\ocamlcodefragment{| \ocamltag{constructor}{Second} : \ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} (unit,\allowbreak{} \ocamltag{type-var}{'a}) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.Second}\\
439
+
\ocamlcodefragment{| \ocamltag{constructor}{Exist} : \ocamltag{type-var}{'a} * \ocamltag{type-var}{'b} \ocamltag{arrow}{$\rightarrow$} (\ocamltag{type-var}{'b},\allowbreak{} unit) \hyperref[Ocamlary--type-full_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}full\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-full_gadt_alias.Exist}\\
433
440
\end{ocamltabular}%
434
441
\\
435
442
\begin{ocamlindent}This comment is for \ocamlinlinecode{full\_\allowbreak{}gadt\_\allowbreak{}alias}.\end{ocamlindent}%
436
443
\medbreak
437
-
\label{Ocamlary--type-partial_gadt_alias}\ocamlcodefragment{\ocamltag{keyword}{type} 'a partial\_\allowbreak{}gadt\_\allowbreak{}alias = \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{partial\_\allowbreak{}gadt}} = }\\
438
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{AscribeTag} : \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt_alias]{\ocamlinlinecode{partial\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-partial_gadt_alias.AscribeTag}\\
439
-
\ocamlcodefragment{| \ocamltag{constructor}{OfTag} \ocamltag{keyword}{of} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt_alias]{\ocamlinlinecode{partial\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-partial_gadt_alias.OfTag}\\
440
-
\ocamlcodefragment{| \ocamltag{constructor}{ExistGadtTag} : (\ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'b}) \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt_alias]{\ocamlinlinecode{partial\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-partial_gadt_alias.ExistGadtTag}\\
444
+
\label{Ocamlary--type-partial_gadt_alias}\ocamlcodefragment{\ocamltag{keyword}{type} 'a partial\_\allowbreak{}gadt\_\allowbreak{}alias = \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt}} = }\\
445
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{AscribeTag} : \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-partial_gadt_alias.AscribeTag}\\
446
+
\ocamlcodefragment{| \ocamltag{constructor}{OfTag} \ocamltag{keyword}{of} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-partial_gadt_alias.OfTag}\\
447
+
\ocamlcodefragment{| \ocamltag{constructor}{ExistGadtTag} : (\ocamltag{type-var}{'a} \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'b}) \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a} \hyperref[Ocamlary--type-partial_gadt_alias]{\ocamlinlinecode{Ocamlary.\allowbreak{}partial\_\allowbreak{}gadt\_\allowbreak{}alias}}}\label{Ocamlary--type-partial_gadt_alias.ExistGadtTag}\\
441
448
\end{ocamltabular}%
442
449
\\
443
450
\begin{ocamlindent}This comment is for \ocamlinlinecode{partial\_\allowbreak{}gadt\_\allowbreak{}alias}.\end{ocamlindent}%
···
446
453
\medbreak
447
454
\label{Ocamlary--type-mutual_constr_a}\ocamlcodefragment{\ocamltag{keyword}{type} mutual\_\allowbreak{}constr\_\allowbreak{}a = }\\
448
455
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A}}\label{Ocamlary--type-mutual_constr_a.A}& \\
449
-
\ocamlcodefragment{| \ocamltag{constructor}{B\_\allowbreak{}ish} \ocamltag{keyword}{of} \hyperref[Ocamlary--type-mutual_constr_b]{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}b}}}\label{Ocamlary--type-mutual_constr_a.B_ish}& This comment is between \hyperref[Ocamlary--type-mutual_constr_a]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}a}}[p\pageref*{Ocamlary--type-mutual_constr_a}]} and \hyperref[Ocamlary--type-mutual_constr_b]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}b}}[p\pageref*{Ocamlary--type-mutual_constr_b}]}.\\
456
+
\ocamlcodefragment{| \ocamltag{constructor}{B\_\allowbreak{}ish} \ocamltag{keyword}{of} \hyperref[Ocamlary--type-mutual_constr_b]{\ocamlinlinecode{Ocamlary.\allowbreak{}mutual\_\allowbreak{}constr\_\allowbreak{}b}}}\label{Ocamlary--type-mutual_constr_a.B_ish}& This comment is between \hyperref[Ocamlary--type-mutual_constr_a]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}a}}[p\pageref*{Ocamlary--type-mutual_constr_a}]} and \hyperref[Ocamlary--type-mutual_constr_b]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}b}}[p\pageref*{Ocamlary--type-mutual_constr_b}]}.\\
450
457
\end{ocamltabular}%
451
458
\\
452
459
\begin{ocamlindent}This comment is for \hyperref[Ocamlary--type-mutual_constr_a]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}a}}[p\pageref*{Ocamlary--type-mutual_constr_a}]} then \hyperref[Ocamlary--type-mutual_constr_b]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}b}}[p\pageref*{Ocamlary--type-mutual_constr_b}]}.\end{ocamlindent}%
453
460
\medbreak
454
461
\label{Ocamlary--type-mutual_constr_b}\ocamlcodefragment{\ocamltag{keyword}{and} mutual\_\allowbreak{}constr\_\allowbreak{}b = }\\
455
462
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{B}}\label{Ocamlary--type-mutual_constr_b.B}& \\
456
-
\ocamlcodefragment{| \ocamltag{constructor}{A\_\allowbreak{}ish} \ocamltag{keyword}{of} \hyperref[Ocamlary--type-mutual_constr_a]{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}a}}}\label{Ocamlary--type-mutual_constr_b.A_ish}& This comment must be here for the next to associate correctly.\\
463
+
\ocamlcodefragment{| \ocamltag{constructor}{A\_\allowbreak{}ish} \ocamltag{keyword}{of} \hyperref[Ocamlary--type-mutual_constr_a]{\ocamlinlinecode{Ocamlary.\allowbreak{}mutual\_\allowbreak{}constr\_\allowbreak{}a}}}\label{Ocamlary--type-mutual_constr_b.A_ish}& This comment must be here for the next to associate correctly.\\
457
464
\end{ocamltabular}%
458
465
\\
459
466
\begin{ocamlindent}This comment is for \hyperref[Ocamlary--type-mutual_constr_b]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}b}}[p\pageref*{Ocamlary--type-mutual_constr_b}]} then \hyperref[Ocamlary--type-mutual_constr_a]{\ocamlinlinecode{\ocamlinlinecode{mutual\_\allowbreak{}constr\_\allowbreak{}a}}[p\pageref*{Ocamlary--type-mutual_constr_a}]}.\end{ocamlindent}%
460
467
\medbreak
461
-
\label{Ocamlary--type-rec_obj}\ocamlcodefragment{\ocamltag{keyword}{type} rec\_\allowbreak{}obj = < f : int ;\allowbreak{} g : unit \ocamltag{arrow}{$\rightarrow$} unit ;\allowbreak{} h : \hyperref[Ocamlary--type-rec_obj]{\ocamlinlinecode{rec\_\allowbreak{}obj}} >}\\
468
+
\label{Ocamlary--type-rec_obj}\ocamlcodefragment{\ocamltag{keyword}{type} rec\_\allowbreak{}obj = < f : int ;\allowbreak{} g : unit \ocamltag{arrow}{$\rightarrow$} unit ;\allowbreak{} h : \hyperref[Ocamlary--type-rec_obj]{\ocamlinlinecode{Ocamlary.\allowbreak{}rec\_\allowbreak{}obj}} >}\\
462
469
\label{Ocamlary--type-open_obj}\ocamlcodefragment{\ocamltag{keyword}{type} 'a open\_\allowbreak{}obj = < f : int ;\allowbreak{} g : unit \ocamltag{arrow}{$\rightarrow$} unit.\allowbreak{}.\allowbreak{} > \ocamltag{keyword}{as} 'a}\\
463
470
\label{Ocamlary--type-oof}\ocamlcodefragment{\ocamltag{keyword}{type} 'a oof = (< a : unit.\allowbreak{}.\allowbreak{} > \ocamltag{keyword}{as} 'a) \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a}}\\
464
471
\label{Ocamlary--type-any_obj}\ocamlcodefragment{\ocamltag{keyword}{type} 'a any\_\allowbreak{}obj = < .\allowbreak{}.\allowbreak{} > \ocamltag{keyword}{as} 'a}\\
···
466
473
\label{Ocamlary--type-one_meth}\ocamlcodefragment{\ocamltag{keyword}{type} one\_\allowbreak{}meth = < meth : unit >}\\
467
474
\label{Ocamlary--type-ext}\ocamlcodefragment{\ocamltag{keyword}{type} ext = .\allowbreak{}.\allowbreak{}}\begin{ocamlindent}A mystery wrapped in an ellipsis\end{ocamlindent}%
468
475
\medbreak
469
-
\label{Ocamlary--extension-decl-ExtA}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{ext}} += }\\
476
+
\label{Ocamlary--extension-decl-ExtA}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}ext}} += }\\
470
477
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ExtA}}\label{Ocamlary--extension-ExtA}\\
471
478
\end{ocamltabular}%
472
479
\\
473
-
\label{Ocamlary--extension-decl-ExtB}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{ext}} += }\\
480
+
\label{Ocamlary--extension-decl-ExtB}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}ext}} += }\\
474
481
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ExtB}}\label{Ocamlary--extension-ExtB}\\
475
482
\end{ocamltabular}%
476
483
\\
477
-
\label{Ocamlary--extension-decl-ExtC}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{ext}} += }\\
484
+
\label{Ocamlary--extension-decl-ExtC}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}ext}} += }\\
478
485
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ExtC} \ocamltag{keyword}{of} unit}\label{Ocamlary--extension-ExtC}\\
479
-
\ocamlcodefragment{| \ocamltag{extension}{ExtD} \ocamltag{keyword}{of} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{ext}}}\label{Ocamlary--extension-ExtD}\\
486
+
\ocamlcodefragment{| \ocamltag{extension}{ExtD} \ocamltag{keyword}{of} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}ext}}}\label{Ocamlary--extension-ExtD}\\
480
487
\end{ocamltabular}%
481
488
\\
482
-
\label{Ocamlary--extension-decl-ExtE}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{ext}} += }\\
489
+
\label{Ocamlary--extension-decl-ExtE}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}ext}} += }\\
483
490
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ExtE}}\label{Ocamlary--extension-ExtE}\\
484
491
\end{ocamltabular}%
485
492
\\
486
-
\label{Ocamlary--extension-decl-ExtF}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{ext}} += \ocamltag{keyword}{private} }\\
493
+
\label{Ocamlary--extension-decl-ExtF}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}ext}} += \ocamltag{keyword}{private} }\\
487
494
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ExtF}}\label{Ocamlary--extension-ExtF}\\
488
495
\end{ocamltabular}%
489
496
\\
490
497
\label{Ocamlary--type-poly_ext}\ocamlcodefragment{\ocamltag{keyword}{type} 'a poly\_\allowbreak{}ext = .\allowbreak{}.\allowbreak{}}\begin{ocamlindent}'a poly\_ext\end{ocamlindent}%
491
498
\medbreak
492
-
\label{Ocamlary--extension-decl-Foo}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-poly_ext]{\ocamlinlinecode{poly\_\allowbreak{}ext}} += }\\
499
+
\label{Ocamlary--extension-decl-Foo}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-poly_ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}poly\_\allowbreak{}ext}} += }\\
493
500
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{Foo} \ocamltag{keyword}{of} \ocamltag{type-var}{'b}}\label{Ocamlary--extension-Foo}& \\
494
501
\ocamlcodefragment{| \ocamltag{extension}{Bar} \ocamltag{keyword}{of} \ocamltag{type-var}{'b} * \ocamltag{type-var}{'b}}\label{Ocamlary--extension-Bar}& 'b poly\_ext\\
495
502
\end{ocamltabular}%
496
503
\\
497
-
\label{Ocamlary--extension-decl-Quux}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-poly_ext]{\ocamlinlinecode{poly\_\allowbreak{}ext}} += }\\
504
+
\label{Ocamlary--extension-decl-Quux}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-poly_ext]{\ocamlinlinecode{Ocamlary.\allowbreak{}poly\_\allowbreak{}ext}} += }\\
498
505
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{Quux} \ocamltag{keyword}{of} \ocamltag{type-var}{'c}}\label{Ocamlary--extension-Quux}& 'c poly\_ext\\
499
506
\end{ocamltabular}%
500
507
\\
501
508
\label{Ocamlary--module-ExtMod}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-ExtMod]{\ocamlinlinecode{ExtMod}}}\label{Ocamlary-ExtMod}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-ExtMod--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = .\allowbreak{}.\allowbreak{}}\\
502
-
\label{Ocamlary-ExtMod--extension-decl-Leisureforce}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary-ExtMod--type-t]{\ocamlinlinecode{t}} += }\\
509
+
\label{Ocamlary-ExtMod--extension-decl-Leisureforce}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary-ExtMod--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}ExtMod.\allowbreak{}t}} += }\\
503
510
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{Leisureforce}}\label{Ocamlary-ExtMod--extension-Leisureforce}\\
504
511
\end{ocamltabular}%
505
512
\\
506
513
\end{ocamlindent}%
507
514
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
508
-
\label{Ocamlary--extension-decl-ZzzTop0}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary-ExtMod--type-t]{\ocamlinlinecode{ExtMod.\allowbreak{}t}} += }\\
515
+
\label{Ocamlary--extension-decl-ZzzTop0}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary-ExtMod--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}ExtMod.\allowbreak{}t}} += }\\
509
516
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ZzzTop0}}\label{Ocamlary--extension-ZzzTop0}& It's got the rock\\
510
517
\end{ocamltabular}%
511
518
\\
512
-
\label{Ocamlary--extension-decl-ZzzTop}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary-ExtMod--type-t]{\ocamlinlinecode{ExtMod.\allowbreak{}t}} += }\\
519
+
\label{Ocamlary--extension-decl-ZzzTop}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary-ExtMod--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}ExtMod.\allowbreak{}t}} += }\\
513
520
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{ZzzTop} \ocamltag{keyword}{of} unit}\label{Ocamlary--extension-ZzzTop}& and it packs a unit.\\
514
521
\end{ocamltabular}%
515
522
\\
516
523
\label{Ocamlary--val-launch_missiles}\ocamlcodefragment{\ocamltag{keyword}{val} launch\_\allowbreak{}missiles : unit \ocamltag{arrow}{$\rightarrow$} unit}\begin{ocamlindent}Rotate keys on my mark...\end{ocamlindent}%
517
524
\medbreak
518
-
\label{Ocamlary--type-my_mod}\ocamlcodefragment{\ocamltag{keyword}{type} my\_\allowbreak{}mod = (\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{COLLECTION}})}\begin{ocamlindent}A brown paper package tied up with string\end{ocamlindent}%
525
+
\label{Ocamlary--type-my_mod}\ocamlcodefragment{\ocamltag{keyword}{type} my\_\allowbreak{}mod = (\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-COLLECTION]{\ocamlinlinecode{Ocamlary.\allowbreak{}COLLECTION}})}\begin{ocamlindent}A brown paper package tied up with string\end{ocamlindent}%
519
526
\medbreak
520
527
\label{Ocamlary--class-empty_class}\ocamlcodefragment{\ocamltag{keyword}{class} \hyperref[Ocamlary-class-empty_class]{\ocamlinlinecode{empty\_\allowbreak{}class}}}\ocamlcodefragment{ : \ocamltag{keyword}{object} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
521
528
\label{Ocamlary--class-one_method_class}\ocamlcodefragment{\ocamltag{keyword}{class} \hyperref[Ocamlary-class-one_method_class]{\ocamlinlinecode{one\_\allowbreak{}method\_\allowbreak{}class}}}\ocamlcodefragment{ : \ocamltag{keyword}{object} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
···
526
533
\label{Ocamlary--module-Dep1}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep1]{\ocamlinlinecode{Dep1}}}\label{Ocamlary-Dep1}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep1--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep1-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-Dep1-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep1-module-type-S--class-c}\ocamlcodefragment{\ocamltag{keyword}{class} \hyperref[Ocamlary-Dep1-module-type-S-class-c]{\ocamlinlinecode{c}}}\ocamlcodefragment{ : \ocamltag{keyword}{object} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
527
534
\end{ocamlindent}%
528
535
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
529
-
\label{Ocamlary-Dep1--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep1-X]{\ocamlinlinecode{X}}}\label{Ocamlary-Dep1-X}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep1-X--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep1-X-Y]{\ocamlinlinecode{Y}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep1-module-type-S]{\ocamlinlinecode{S}}}\\
536
+
\label{Ocamlary-Dep1--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep1-X]{\ocamlinlinecode{X}}}\label{Ocamlary-Dep1-X}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep1-X--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep1-X-Y]{\ocamlinlinecode{Y}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep1-module-type-S]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep1.\allowbreak{}S}}}\\
530
537
\end{ocamlindent}%
531
538
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
532
539
\end{ocamlindent}%
···
539
546
\label{Ocamlary--module-Dep4}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep4]{\ocamlinlinecode{Dep4}}}\label{Ocamlary-Dep4}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep4--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep4-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-Dep4-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep4-module-type-T--type-b}\ocamlcodefragment{\ocamltag{keyword}{type} b}\\
540
547
\end{ocamlindent}%
541
548
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
542
-
\label{Ocamlary-Dep4--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep4-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-Dep4-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep4-module-type-S--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep4-module-type-S-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep4-module-type-T]{\ocamlinlinecode{T}}}\\
549
+
\label{Ocamlary-Dep4--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep4-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-Dep4-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep4-module-type-S--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep4-module-type-S-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep4-module-type-T]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep4.\allowbreak{}T}}}\\
543
550
\label{Ocamlary-Dep4-module-type-S--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep4-module-type-S-Y]{\ocamlinlinecode{Y}}}\label{Ocamlary-Dep4-module-type-S-Y}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
544
551
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
545
552
\end{ocamlindent}%
546
553
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
547
-
\label{Ocamlary-Dep4--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep4-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep4-module-type-T]{\ocamlinlinecode{T}}}\\
554
+
\label{Ocamlary-Dep4--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep4-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep4-module-type-T]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep4.\allowbreak{}T}}}\\
548
555
\end{ocamlindent}%
549
556
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
550
557
\label{Ocamlary--module-Dep5}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep5]{\ocamlinlinecode{Dep5}}}\ocamlcodefragment{ (\hyperref[Ocamlary-Dep5-argument-1-Arg]{\ocamlinlinecode{Arg}} : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
551
-
\label{Ocamlary--type-dep2}\ocamlcodefragment{\ocamltag{keyword}{type} dep2 = \hyperref[Ocamlary-Dep4-module-type-T--type-b]{\ocamlinlinecode{Dep5(Dep4).\allowbreak{}Z.\allowbreak{}X.\allowbreak{}b}}}\\
558
+
\label{Ocamlary--type-dep2}\ocamlcodefragment{\ocamltag{keyword}{type} dep2 = \hyperref[Ocamlary-Dep4-module-type-T--type-b]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep5(Ocamlary.\allowbreak{}Dep4).\allowbreak{}Z.\allowbreak{}X.\allowbreak{}b}}}\\
552
559
\label{Ocamlary--type-dep3}\ocamlcodefragment{\ocamltag{keyword}{type} dep3 = \hyperref[Ocamlary-Dep3--type-a]{\ocamlinlinecode{Dep5(Dep4).\allowbreak{}Z.\allowbreak{}Y.\allowbreak{}a}}}\\
553
560
\label{Ocamlary--module-Dep6}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep6]{\ocamlinlinecode{Dep6}}}\label{Ocamlary-Dep6}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep6--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep6-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-Dep6-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep6-module-type-S--type-d}\ocamlcodefragment{\ocamltag{keyword}{type} d}\\
554
561
\end{ocamlindent}%
555
562
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
556
-
\label{Ocamlary-Dep6--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep6-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-Dep6-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep6-module-type-T--module-type-R}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} R = \hyperref[Ocamlary-Dep6-module-type-S]{\ocamlinlinecode{S}}}\\
563
+
\label{Ocamlary-Dep6--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep6-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-Dep6-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep6-module-type-T--module-type-R}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} R = \hyperref[Ocamlary-Dep6-module-type-S]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep6.\allowbreak{}S}}}\\
557
564
\label{Ocamlary-Dep6-module-type-T--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep6-module-type-T-Y]{\ocamlinlinecode{Y}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep6-module-type-S]{\ocamlinlinecode{R}}}\\
558
565
\end{ocamlindent}%
559
566
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
560
-
\label{Ocamlary-Dep6--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep6-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep6-module-type-T]{\ocamlinlinecode{T}}}\\
567
+
\label{Ocamlary-Dep6--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep6-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep6-module-type-T]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep6.\allowbreak{}T}}}\\
561
568
\end{ocamlindent}%
562
569
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
563
570
\label{Ocamlary--module-Dep7}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep7]{\ocamlinlinecode{Dep7}}}\ocamlcodefragment{ (\hyperref[Ocamlary-Dep7-argument-1-Arg]{\ocamlinlinecode{Arg}} : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
564
-
\label{Ocamlary--type-dep4}\ocamlcodefragment{\ocamltag{keyword}{type} dep4 = \hyperref[Ocamlary-Dep6-module-type-T-Y--type-d]{\ocamlinlinecode{Dep7(Dep6).\allowbreak{}M.\allowbreak{}Y.\allowbreak{}d}}}\\
571
+
\label{Ocamlary--type-dep4}\ocamlcodefragment{\ocamltag{keyword}{type} dep4 = \hyperref[Ocamlary-Dep6-module-type-T-Y--type-d]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep7(Ocamlary.\allowbreak{}Dep6).\allowbreak{}M.\allowbreak{}Y.\allowbreak{}d}}}\\
565
572
\label{Ocamlary--module-Dep8}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep8]{\ocamlinlinecode{Dep8}}}\label{Ocamlary-Dep8}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep8--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-Dep8-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-Dep8-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Dep8-module-type-T--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
566
573
\end{ocamlindent}%
567
574
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
···
577
584
\end{ocamlindent}%
578
585
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
579
586
\label{Ocamlary--module-Dep12}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep12]{\ocamlinlinecode{Dep12}}}\ocamlcodefragment{ (\hyperref[Ocamlary-Dep12-argument-1-Arg]{\ocamlinlinecode{Arg}} : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
580
-
\label{Ocamlary--module-Dep13}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep13]{\ocamlinlinecode{Dep13}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep11-module-type-S]{\ocamlinlinecode{Dep12(Dep11).\allowbreak{}T}}}\\
581
-
\label{Ocamlary--type-dep5}\ocamlcodefragment{\ocamltag{keyword}{type} dep5 = \hyperref[Ocamlary-Dep11-module-type-S-class-c]{\ocamlinlinecode{Dep13.\allowbreak{}c}}}\\
587
+
\label{Ocamlary--module-Dep13}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Dep13]{\ocamlinlinecode{Dep13}}}\ocamlcodefragment{ : \hyperref[Ocamlary-Dep11-module-type-S]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep12(Ocamlary.\allowbreak{}Dep11).\allowbreak{}T}}}\\
588
+
\label{Ocamlary--type-dep5}\ocamlcodefragment{\ocamltag{keyword}{type} dep5 = \hyperref[Ocamlary-Dep11-module-type-S-class-c]{\ocamlinlinecode{Ocamlary.\allowbreak{}Dep13.\allowbreak{}c}}}\\
582
589
\label{Ocamlary--module-type-With1}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-With1]{\ocamlinlinecode{With1}}}\label{Ocamlary-module-type-With1}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-With1--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With1-M]{\ocamlinlinecode{M}}}\label{Ocamlary-module-type-With1-M}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-With1-M--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S}\\
583
590
\end{ocamlindent}%
584
591
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
···
590
597
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
591
598
\end{ocamlindent}%
592
599
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
593
-
\label{Ocamlary--module-With3}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With3]{\ocamlinlinecode{With3}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-With1]{\ocamlinlinecode{With1}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With1-M]{\ocamlinlinecode{M}} = \hyperref[Ocamlary-With2]{\ocamlinlinecode{With2}}}\\
594
-
\label{Ocamlary--type-with1}\ocamlcodefragment{\ocamltag{keyword}{type} with1 = \hyperref[Ocamlary-With3-N--type-t]{\ocamlinlinecode{With3.\allowbreak{}N.\allowbreak{}t}}}\\
595
-
\label{Ocamlary--module-With4}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With4]{\ocamlinlinecode{With4}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-With1]{\ocamlinlinecode{With1}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With1-M]{\ocamlinlinecode{M}} := \hyperref[Ocamlary-With2]{\ocamlinlinecode{With2}}}\\
596
-
\label{Ocamlary--type-with2}\ocamlcodefragment{\ocamltag{keyword}{type} with2 = \hyperref[Ocamlary-With4-N--type-t]{\ocamlinlinecode{With4.\allowbreak{}N.\allowbreak{}t}}}\\
600
+
\label{Ocamlary--module-With3}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With3]{\ocamlinlinecode{With3}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-With1]{\ocamlinlinecode{Ocamlary.\allowbreak{}With1}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With1-M]{\ocamlinlinecode{M}} = \hyperref[Ocamlary-With2]{\ocamlinlinecode{Ocamlary.\allowbreak{}With2}}}\\
601
+
\label{Ocamlary--type-with1}\ocamlcodefragment{\ocamltag{keyword}{type} with1 = \hyperref[Ocamlary-With3-N--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}With3.\allowbreak{}N.\allowbreak{}t}}}\\
602
+
\label{Ocamlary--module-With4}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With4]{\ocamlinlinecode{With4}}}\ocamlcodefragment{ : \hyperref[Ocamlary-module-type-With1]{\ocamlinlinecode{Ocamlary.\allowbreak{}With1}} \ocamltag{keyword}{with} \ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With1-M]{\ocamlinlinecode{M}} := \hyperref[Ocamlary-With2]{\ocamlinlinecode{Ocamlary.\allowbreak{}With2}}}\\
603
+
\label{Ocamlary--type-with2}\ocamlcodefragment{\ocamltag{keyword}{type} with2 = \hyperref[Ocamlary-With4-N--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}With4.\allowbreak{}N.\allowbreak{}t}}}\\
597
604
\label{Ocamlary--module-With5}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With5]{\ocamlinlinecode{With5}}}\label{Ocamlary-With5}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With5--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-With5-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-With5-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With5-module-type-S--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
598
605
\end{ocamlindent}%
599
606
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
600
-
\label{Ocamlary-With5--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With5-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \hyperref[Ocamlary-With5-module-type-S]{\ocamlinlinecode{S}}}\\
607
+
\label{Ocamlary-With5--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With5-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \hyperref[Ocamlary-With5-module-type-S]{\ocamlinlinecode{Ocamlary.\allowbreak{}With5.\allowbreak{}S}}}\\
601
608
\end{ocamlindent}%
602
609
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
603
610
\label{Ocamlary--module-With6}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With6]{\ocamlinlinecode{With6}}}\label{Ocamlary-With6}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With6--module-type-T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-With6-module-type-T]{\ocamlinlinecode{T}}}\label{Ocamlary-With6-module-type-T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With6-module-type-T--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With6-module-type-T-M]{\ocamlinlinecode{M}}}\label{Ocamlary-With6-module-type-T-M}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With6-module-type-T-M--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} S}\\
604
-
\label{Ocamlary-With6-module-type-T-M--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} N : \hyperref[Ocamlary-With6-module-type-T-M--module-type-S]{\ocamlinlinecode{S}}}\\
611
+
\label{Ocamlary-With6-module-type-T-M--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} N : \hyperref[Ocamlary-With6-module-type-T-M--module-type-S]{\ocamlinlinecode{M.\allowbreak{}S}}}\\
605
612
\end{ocamlindent}%
606
613
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
607
614
\end{ocamlindent}%
···
609
616
\end{ocamlindent}%
610
617
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
611
618
\label{Ocamlary--module-With7}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With7]{\ocamlinlinecode{With7}}}\ocamlcodefragment{ (\hyperref[Ocamlary-With7-argument-1-X]{\ocamlinlinecode{X}} : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}) : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
612
-
\label{Ocamlary--module-type-With8}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-With8]{\ocamlinlinecode{With8}}}\label{Ocamlary-module-type-With8}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-With8--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With8-M]{\ocamlinlinecode{M}}}\ocamlcodefragment{ : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Ocamlary-With5]{\ocamlinlinecode{With5}} \ocamltag{keyword}{end} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-With5-N--type-t]{\ocamlinlinecode{N.\allowbreak{}t}} = \hyperref[Ocamlary-With5-N--type-t]{\ocamlinlinecode{With5.\allowbreak{}N.\allowbreak{}t}}}\\
619
+
\label{Ocamlary--module-type-With8}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-With8]{\ocamlinlinecode{With8}}}\label{Ocamlary-module-type-With8}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-With8--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With8-M]{\ocamlinlinecode{M}}}\ocamlcodefragment{ :
620
+
\ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \ocamltag{keyword}{struct} \ocamltag{keyword}{include} \hyperref[Ocamlary-With5]{\ocamlinlinecode{Ocamlary.\allowbreak{}With5}} \ocamltag{keyword}{end}
621
+
\ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-With5-N--type-t]{\ocamlinlinecode{N.\allowbreak{}t}} = \hyperref[Ocamlary-With5-N--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}With5.\allowbreak{}N.\allowbreak{}t}}}\\
613
622
\end{ocamlindent}%
614
623
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
615
624
\label{Ocamlary--module-With9}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-With9]{\ocamlinlinecode{With9}}}\label{Ocamlary-With9}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With9--module-type-S}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-With9-module-type-S]{\ocamlinlinecode{S}}}\label{Ocamlary-With9-module-type-S}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-With9-module-type-S--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
···
626
635
\medbreak
627
636
\end{ocamlindent}%
628
637
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
629
-
\label{Ocamlary--module-type-With11}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-With11]{\ocamlinlinecode{With11}}}\label{Ocamlary-module-type-With11}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-With11--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Ocamlary-With9]{\ocamlinlinecode{With9}}}\\
638
+
\label{Ocamlary--module-type-With11}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-With11]{\ocamlinlinecode{With11}}}\label{Ocamlary-module-type-With11}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-With11--module-M}\ocamlcodefragment{\ocamltag{keyword}{module} M = \hyperref[Ocamlary-With9]{\ocamlinlinecode{Ocamlary.\allowbreak{}With9}}}\\
630
639
\label{Ocamlary-module-type-With11--module-N}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-module-type-With11-N]{\ocamlinlinecode{N}}}\ocamlcodefragment{ : \hyperref[Ocamlary-With9-module-type-S]{\ocamlinlinecode{M.\allowbreak{}S}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-With9-module-type-S--type-t]{\ocamlinlinecode{t}} = int}\\
631
640
\end{ocamlindent}%
632
641
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
···
635
644
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
636
645
\end{ocamlindent}%
637
646
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
638
-
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-NestedInclude1]{\ocamlinlinecode{NestedInclude1}}\label{Ocamlary--module-type-NestedInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-NestedInclude2]{\ocamlinlinecode{NestedInclude2}}}\label{Ocamlary-module-type-NestedInclude2}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-NestedInclude2--type-nested_include}\ocamlcodefragment{\ocamltag{keyword}{type} nested\_\allowbreak{}include}\\
647
+
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-NestedInclude1]{\ocamlinlinecode{Ocamlary.\allowbreak{}NestedInclude1}}\label{Ocamlary--module-type-NestedInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-NestedInclude2]{\ocamlinlinecode{NestedInclude2}}}\label{Ocamlary-module-type-NestedInclude2}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-NestedInclude2--type-nested_include}\ocamlcodefragment{\ocamltag{keyword}{type} nested\_\allowbreak{}include}\\
639
648
\end{ocamlindent}%
640
649
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
641
-
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-NestedInclude2]{\ocamlinlinecode{NestedInclude2}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-NestedInclude2--type-nested_include]{\ocamlinlinecode{nested\_\allowbreak{}include}} = int\label{Ocamlary--type-nested_include}\ocamlcodefragment{\ocamltag{keyword}{type} nested\_\allowbreak{}include = int}\\
650
+
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-NestedInclude2]{\ocamlinlinecode{Ocamlary.\allowbreak{}NestedInclude2}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-NestedInclude2--type-nested_include]{\ocamlinlinecode{nested\_\allowbreak{}include}} = int\label{Ocamlary--type-nested_include}\ocamlcodefragment{\ocamltag{keyword}{type} nested\_\allowbreak{}include = int}\\
642
651
\label{Ocamlary--module-DoubleInclude1}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-DoubleInclude1]{\ocamlinlinecode{DoubleInclude1}}}\label{Ocamlary-DoubleInclude1}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-DoubleInclude1--module-DoubleInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-DoubleInclude1-DoubleInclude2]{\ocamlinlinecode{DoubleInclude2}}}\label{Ocamlary-DoubleInclude1-DoubleInclude2}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-DoubleInclude1-DoubleInclude2--type-double_include}\ocamlcodefragment{\ocamltag{keyword}{type} double\_\allowbreak{}include}\\
643
652
\end{ocamlindent}%
644
653
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
645
654
\end{ocamlindent}%
646
655
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
647
-
\label{Ocamlary--module-DoubleInclude3}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-DoubleInclude3]{\ocamlinlinecode{DoubleInclude3}}}\label{Ocamlary-DoubleInclude3}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-DoubleInclude1]{\ocamlinlinecode{DoubleInclude1}}\label{Ocamlary-DoubleInclude3--module-DoubleInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-DoubleInclude3-DoubleInclude2]{\ocamlinlinecode{DoubleInclude2}}}\label{Ocamlary-DoubleInclude3-DoubleInclude2}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-DoubleInclude3-DoubleInclude2--type-double_include}\ocamlcodefragment{\ocamltag{keyword}{type} double\_\allowbreak{}include}\\
656
+
\label{Ocamlary--module-DoubleInclude3}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-DoubleInclude3]{\ocamlinlinecode{DoubleInclude3}}}\label{Ocamlary-DoubleInclude3}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-DoubleInclude1]{\ocamlinlinecode{Ocamlary.\allowbreak{}DoubleInclude1}}\label{Ocamlary-DoubleInclude3--module-DoubleInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-DoubleInclude3-DoubleInclude2]{\ocamlinlinecode{DoubleInclude2}}}\label{Ocamlary-DoubleInclude3-DoubleInclude2}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-DoubleInclude3-DoubleInclude2--type-double_include}\ocamlcodefragment{\ocamltag{keyword}{type} double\_\allowbreak{}include}\\
648
657
\end{ocamlindent}%
649
658
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
650
659
\end{ocamlindent}%
651
660
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
652
-
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-DoubleInclude3-DoubleInclude2]{\ocamlinlinecode{DoubleInclude3.\allowbreak{}DoubleInclude2}}\label{Ocamlary--type-double_include}\ocamlcodefragment{\ocamltag{keyword}{type} double\_\allowbreak{}include}\\
661
+
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-DoubleInclude3-DoubleInclude2]{\ocamlinlinecode{Ocamlary.\allowbreak{}DoubleInclude3.\allowbreak{}DoubleInclude2}}\label{Ocamlary--type-double_include}\ocamlcodefragment{\ocamltag{keyword}{type} double\_\allowbreak{}include}\\
653
662
\label{Ocamlary--module-IncludeInclude1}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-IncludeInclude1]{\ocamlinlinecode{IncludeInclude1}}}\label{Ocamlary-IncludeInclude1}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-IncludeInclude1--module-type-IncludeInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-IncludeInclude1-module-type-IncludeInclude2]{\ocamlinlinecode{IncludeInclude2}}}\label{Ocamlary-IncludeInclude1-module-type-IncludeInclude2}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-IncludeInclude1-module-type-IncludeInclude2--type-include_include}\ocamlcodefragment{\ocamltag{keyword}{type} include\_\allowbreak{}include}\\
654
663
\end{ocamlindent}%
655
664
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
···
657
666
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
658
667
\end{ocamlindent}%
659
668
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
660
-
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-IncludeInclude1]{\ocamlinlinecode{IncludeInclude1}}\label{Ocamlary--module-type-IncludeInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-IncludeInclude2]{\ocamlinlinecode{IncludeInclude2}}}\label{Ocamlary-module-type-IncludeInclude2}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-IncludeInclude2--type-include_include}\ocamlcodefragment{\ocamltag{keyword}{type} include\_\allowbreak{}include}\\
669
+
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-IncludeInclude1]{\ocamlinlinecode{Ocamlary.\allowbreak{}IncludeInclude1}}\label{Ocamlary--module-type-IncludeInclude2}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-IncludeInclude2]{\ocamlinlinecode{IncludeInclude2}}}\label{Ocamlary-module-type-IncludeInclude2}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-IncludeInclude2--type-include_include}\ocamlcodefragment{\ocamltag{keyword}{type} include\_\allowbreak{}include}\\
661
670
\end{ocamlindent}%
662
671
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
663
672
\label{Ocamlary--module-IncludeInclude2_M}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-IncludeInclude2_M]{\ocamlinlinecode{IncludeInclude2\_\allowbreak{}M}}}\label{Ocamlary-IncludeInclude2_M}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
664
673
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
665
-
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-IncludeInclude2]{\ocamlinlinecode{IncludeInclude2}}\label{Ocamlary--type-include_include}\ocamlcodefragment{\ocamltag{keyword}{type} include\_\allowbreak{}include}\\
674
+
\ocamltag{keyword}{include} \hyperref[Ocamlary-module-type-IncludeInclude2]{\ocamlinlinecode{Ocamlary.\allowbreak{}IncludeInclude2}}\label{Ocamlary--type-include_include}\ocamlcodefragment{\ocamltag{keyword}{type} include\_\allowbreak{}include}\\
666
675
\subsection{Trying the \{!modules: ...\} command.\label{Ocamlary--indexmodules}}%
667
676
With ocamldoc, toplevel units will be linked and documented, while submodules will behave as simple references.
668
677
···
682
691
\label{Ocamlary--module-CanonicalTest}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest]{\ocamlinlinecode{CanonicalTest}}}\label{Ocamlary-CanonicalTest}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CanonicalTest--module-Base}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-Base]{\ocamlinlinecode{Base}}}\label{Ocamlary-CanonicalTest-Base}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CanonicalTest-Base--module-List}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{List}}}\ocamlcodefragment{ : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
683
692
\end{ocamlindent}%
684
693
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
685
-
\label{Ocamlary-CanonicalTest--module-Base_Tests}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-Base_Tests]{\ocamlinlinecode{Base\_\allowbreak{}Tests}}}\label{Ocamlary-CanonicalTest-Base_Tests}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CanonicalTest-Base_Tests--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-Base_Tests-C]{\ocamlinlinecode{C}}}\ocamlcodefragment{ : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{Base.\allowbreak{}List}}}\\
686
-
\label{Ocamlary-CanonicalTest-Base_Tests--module-L}\ocamlcodefragment{\ocamltag{keyword}{module} L = \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{Base.\allowbreak{}List}}}\\
694
+
\label{Ocamlary-CanonicalTest--module-Base_Tests}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-Base_Tests]{\ocamlinlinecode{Base\_\allowbreak{}Tests}}}\label{Ocamlary-CanonicalTest-Base_Tests}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-CanonicalTest-Base_Tests--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-Base_Tests-C]{\ocamlinlinecode{C}}}\ocamlcodefragment{ : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{Ocamlary.\allowbreak{}CanonicalTest.\allowbreak{}Base.\allowbreak{}List}}}\\
695
+
\label{Ocamlary-CanonicalTest-Base_Tests--module-L}\ocamlcodefragment{\ocamltag{keyword}{module} L = \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{Ocamlary.\allowbreak{}CanonicalTest.\allowbreak{}Base.\allowbreak{}List}}}\\
687
696
\label{Ocamlary-CanonicalTest-Base_Tests--val-foo}\ocamlcodefragment{\ocamltag{keyword}{val} foo : int \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{L.\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} float \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{L.\allowbreak{}t}}}\\
688
-
\label{Ocamlary-CanonicalTest-Base_Tests--val-bar}\ocamlcodefragment{\ocamltag{keyword}{val} bar : \ocamltag{type-var}{'a} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Base.\allowbreak{}List.\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} \ocamltag{type-var}{'a} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Base.\allowbreak{}List.\allowbreak{}t}}}\\
689
-
\label{Ocamlary-CanonicalTest-Base_Tests--val-baz}\ocamlcodefragment{\ocamltag{keyword}{val} baz : \ocamltag{type-var}{'a} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Base.\allowbreak{}List.\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} unit}\\
697
+
\label{Ocamlary-CanonicalTest-Base_Tests--val-bar}\ocamlcodefragment{\ocamltag{keyword}{val} bar :
698
+
\ocamltag{type-var}{'a} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}CanonicalTest.\allowbreak{}Base.\allowbreak{}List.\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$}
699
+
\ocamltag{type-var}{'a} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}CanonicalTest.\allowbreak{}Base.\allowbreak{}List.\allowbreak{}t}}}\\
700
+
\label{Ocamlary-CanonicalTest-Base_Tests--val-baz}\ocamlcodefragment{\ocamltag{keyword}{val} baz : \ocamltag{type-var}{'a} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}CanonicalTest.\allowbreak{}Base.\allowbreak{}List.\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} unit}\\
690
701
\end{ocamlindent}%
691
702
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
692
-
\label{Ocamlary-CanonicalTest--module-List_modif}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-List_modif]{\ocamlinlinecode{List\_\allowbreak{}modif}}}\ocamlcodefragment{ : \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{Base.\allowbreak{}List}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} 'c \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{t}} = \ocamltag{type-var}{'c} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Base.\allowbreak{}List.\allowbreak{}t}}}\\
703
+
\label{Ocamlary-CanonicalTest--module-List_modif}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-CanonicalTest-List_modif]{\ocamlinlinecode{List\_\allowbreak{}modif}}}\ocamlcodefragment{ :
704
+
\ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{Base.\allowbreak{}List}}
705
+
\ocamltag{keyword}{with} \ocamltag{keyword}{type} 'c \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{t}} = \ocamltag{type-var}{'c} \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}CanonicalTest.\allowbreak{}Base.\allowbreak{}List.\allowbreak{}t}}}\\
693
706
\end{ocamlindent}%
694
707
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
695
708
Some ref to \hyperref[Ocamlary-CanonicalTest-Base_Tests-C--type-t]{\ocamlinlinecode{\ocamlinlinecode{CanonicalTest.\allowbreak{}Base\_\allowbreak{}Tests.\allowbreak{}C.\allowbreak{}t}}[p\pageref*{Ocamlary-CanonicalTest-Base_Tests-C--type-t}]} and \hyperref[Ocamlary-CanonicalTest-Base-List--val-id]{\ocamlinlinecode{\ocamlinlinecode{CanonicalTest.\allowbreak{}Base\_\allowbreak{}Tests.\allowbreak{}L.\allowbreak{}id}}[p\pageref*{Ocamlary-CanonicalTest-Base-List--val-id}]}. But also to \hyperref[Ocamlary-CanonicalTest-Base-List]{\ocamlinlinecode{\ocamlinlinecode{CanonicalTest.\allowbreak{}Base.\allowbreak{}List}}[p\pageref*{Ocamlary-CanonicalTest-Base-List}]} and \hyperref[Ocamlary-CanonicalTest-Base-List--type-t]{\ocamlinlinecode{\ocamlinlinecode{CanonicalTest.\allowbreak{}Base.\allowbreak{}List.\allowbreak{}t}}[p\pageref*{Ocamlary-CanonicalTest-Base-List--type-t}]}
···
704
717
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
705
718
\label{Ocamlary-Aliases--module-A'}\ocamlcodefragment{\ocamltag{keyword}{module} A' = \hyperref[Ocamlary-Aliases-Foo-A]{\ocamlinlinecode{Foo.\allowbreak{}A}}}\\
706
719
\label{Ocamlary-Aliases--type-tata}\ocamlcodefragment{\ocamltag{keyword}{type} tata = \hyperref[Ocamlary-Aliases-Foo-A--type-t]{\ocamlinlinecode{Foo.\allowbreak{}A.\allowbreak{}t}}}\\
707
-
\label{Ocamlary-Aliases--type-tbtb}\ocamlcodefragment{\ocamltag{keyword}{type} tbtb = \hyperref[Ocamlary-Aliases-Foo-B--type-t]{\ocamlinlinecode{Foo.\allowbreak{}B.\allowbreak{}t}}}\\
720
+
\label{Ocamlary-Aliases--type-tbtb}\ocamlcodefragment{\ocamltag{keyword}{type} tbtb = \hyperref[Ocamlary-Aliases-Foo-B--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}B.\allowbreak{}t}}}\\
708
721
\label{Ocamlary-Aliases--type-tete}\ocamlcodefragment{\ocamltag{keyword}{type} tete}\\
709
722
\label{Ocamlary-Aliases--type-tata'}\ocamlcodefragment{\ocamltag{keyword}{type} tata' = \hyperref[Ocamlary-Aliases-Foo-A--type-t]{\ocamlinlinecode{A'.\allowbreak{}t}}}\\
710
-
\label{Ocamlary-Aliases--type-tete2}\ocamlcodefragment{\ocamltag{keyword}{type} tete2 = \hyperref[Ocamlary-Aliases-Foo-E--type-t]{\ocamlinlinecode{Foo.\allowbreak{}E.\allowbreak{}t}}}\\
723
+
\label{Ocamlary-Aliases--type-tete2}\ocamlcodefragment{\ocamltag{keyword}{type} tete2 = \hyperref[Ocamlary-Aliases-Foo-E--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}E.\allowbreak{}t}}}\\
711
724
\label{Ocamlary-Aliases--module-Std}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Aliases-Std]{\ocamlinlinecode{Std}}}\label{Ocamlary-Aliases-Std}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Aliases-Std--module-A}\ocamlcodefragment{\ocamltag{keyword}{module} A = \hyperref[Ocamlary-Aliases-Foo-A]{\ocamlinlinecode{Foo.\allowbreak{}A}}}\\
712
725
\label{Ocamlary-Aliases-Std--module-B}\ocamlcodefragment{\ocamltag{keyword}{module} B = \hyperref[Ocamlary-Aliases-Foo-B]{\ocamlinlinecode{Foo.\allowbreak{}B}}}\\
713
726
\label{Ocamlary-Aliases-Std--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} C = \hyperref[Ocamlary-Aliases-Foo-C]{\ocamlinlinecode{Foo.\allowbreak{}C}}}\\
714
727
\label{Ocamlary-Aliases-Std--module-D}\ocamlcodefragment{\ocamltag{keyword}{module} D = \hyperref[Ocamlary-Aliases-Foo-D]{\ocamlinlinecode{Foo.\allowbreak{}D}}}\\
715
-
\label{Ocamlary-Aliases-Std--module-E}\ocamlcodefragment{\ocamltag{keyword}{module} E = \hyperref[Ocamlary-Aliases-Foo-E]{\ocamlinlinecode{Foo.\allowbreak{}E}}}\\
728
+
\label{Ocamlary-Aliases-Std--module-E}\ocamlcodefragment{\ocamltag{keyword}{module} E = \hyperref[Ocamlary-Aliases-Foo-E]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}E}}}\\
716
729
\end{ocamlindent}%
717
730
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
718
731
\label{Ocamlary-Aliases--type-stde}\ocamlcodefragment{\ocamltag{keyword}{type} stde = \hyperref[Ocamlary-Aliases-Foo-E--type-t]{\ocamlinlinecode{Std.\allowbreak{}E.\allowbreak{}t}}}\\
719
732
\subsubsection{include of Foo\label{Ocamlary-Aliases--incl}}%
720
733
Just for giggle, let's see what happens when we include \hyperref[Ocamlary-Aliases-Foo]{\ocamlinlinecode{\ocamlinlinecode{Foo}}[p\pageref*{Ocamlary-Aliases-Foo}]}.
721
734
722
-
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-Aliases-Foo]{\ocamlinlinecode{Foo}}\label{Ocamlary-Aliases--module-A}\ocamlcodefragment{\ocamltag{keyword}{module} A = \hyperref[Ocamlary-Aliases-Foo-A]{\ocamlinlinecode{Foo.\allowbreak{}A}}}\\
723
-
\label{Ocamlary-Aliases--module-B}\ocamlcodefragment{\ocamltag{keyword}{module} B = \hyperref[Ocamlary-Aliases-Foo-B]{\ocamlinlinecode{Foo.\allowbreak{}B}}}\\
724
-
\label{Ocamlary-Aliases--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} C = \hyperref[Ocamlary-Aliases-Foo-C]{\ocamlinlinecode{Foo.\allowbreak{}C}}}\\
725
-
\label{Ocamlary-Aliases--module-D}\ocamlcodefragment{\ocamltag{keyword}{module} D = \hyperref[Ocamlary-Aliases-Foo-D]{\ocamlinlinecode{Foo.\allowbreak{}D}}}\\
735
+
\ocamltag{keyword}{include} \ocamltag{keyword}{module} \ocamltag{keyword}{type} \ocamltag{keyword}{of} \hyperref[Ocamlary-Aliases-Foo]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo}}\label{Ocamlary-Aliases--module-A}\ocamlcodefragment{\ocamltag{keyword}{module} A = \hyperref[Ocamlary-Aliases-Foo-A]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}A}}}\\
736
+
\label{Ocamlary-Aliases--module-B}\ocamlcodefragment{\ocamltag{keyword}{module} B = \hyperref[Ocamlary-Aliases-Foo-B]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}B}}}\\
737
+
\label{Ocamlary-Aliases--module-C}\ocamlcodefragment{\ocamltag{keyword}{module} C = \hyperref[Ocamlary-Aliases-Foo-C]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}C}}}\\
738
+
\label{Ocamlary-Aliases--module-D}\ocamlcodefragment{\ocamltag{keyword}{module} D = \hyperref[Ocamlary-Aliases-Foo-D]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}Foo.\allowbreak{}D}}}\\
726
739
\label{Ocamlary-Aliases--module-E}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Aliases-E]{\ocamlinlinecode{E}}}\ocamlcodefragment{ : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
727
740
\label{Ocamlary-Aliases--type-testa}\ocamlcodefragment{\ocamltag{keyword}{type} testa = \hyperref[Ocamlary-Aliases-Foo-A--type-t]{\ocamlinlinecode{A.\allowbreak{}t}}}\\
728
741
And also, let's refer to \hyperref[Ocamlary-Aliases-Foo-A--type-t]{\ocamlinlinecode{\ocamlinlinecode{A.\allowbreak{}t}}[p\pageref*{Ocamlary-Aliases-Foo-A--type-t}]} and \hyperref[Ocamlary-Aliases-Foo-B--val-id]{\ocamlinlinecode{\ocamlinlinecode{Foo.\allowbreak{}B.\allowbreak{}id}}[p\pageref*{Ocamlary-Aliases-Foo-B--val-id}]}
729
742
730
743
\label{Ocamlary-Aliases--module-P1}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Aliases-P1]{\ocamlinlinecode{P1}}}\label{Ocamlary-Aliases-P1}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Aliases-P1--module-Y}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Aliases-P1-Y]{\ocamlinlinecode{Y}}}\label{Ocamlary-Aliases-P1-Y}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Aliases-P1-Y--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
731
-
\label{Ocamlary-Aliases-P1-Y--val-id}\ocamlcodefragment{\ocamltag{keyword}{val} id : \hyperref[Ocamlary-Aliases-P1-Y--type-t]{\ocamlinlinecode{t}} \ocamltag{arrow}{$\rightarrow$} \hyperref[Ocamlary-Aliases-P1-Y--type-t]{\ocamlinlinecode{t}}}\\
744
+
\label{Ocamlary-Aliases-P1-Y--val-id}\ocamlcodefragment{\ocamltag{keyword}{val} id : \hyperref[Ocamlary-Aliases-P1-Y--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}P1.\allowbreak{}Y.\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} \hyperref[Ocamlary-Aliases-P1-Y--type-t]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}P1.\allowbreak{}Y.\allowbreak{}t}}}\\
732
745
\end{ocamlindent}%
733
746
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
734
747
\end{ocamlindent}%
···
736
749
\label{Ocamlary-Aliases--module-P2}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Aliases-P2]{\ocamlinlinecode{P2}}}\label{Ocamlary-Aliases-P2}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Aliases-P2--module-Z}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Aliases-P2-Z]{\ocamlinlinecode{Z}}}\ocamlcodefragment{ : \ocamltag{keyword}{sig} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\\
737
750
\end{ocamlindent}%
738
751
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
739
-
\label{Ocamlary-Aliases--module-X1}\ocamlcodefragment{\ocamltag{keyword}{module} X1 = \hyperref[Ocamlary-Aliases-P2-Z]{\ocamlinlinecode{P2.\allowbreak{}Z}}}\\
752
+
\label{Ocamlary-Aliases--module-X1}\ocamlcodefragment{\ocamltag{keyword}{module} X1 = \hyperref[Ocamlary-Aliases-P2-Z]{\ocamlinlinecode{Ocamlary.\allowbreak{}Aliases.\allowbreak{}P2.\allowbreak{}Z}}}\\
740
753
\label{Ocamlary-Aliases--module-X2}\ocamlcodefragment{\ocamltag{keyword}{module} X2 = \hyperref[Ocamlary-Aliases-P2-Z]{\ocamlinlinecode{P2.\allowbreak{}Z}}}\\
741
754
\label{Ocamlary-Aliases--type-p1}\ocamlcodefragment{\ocamltag{keyword}{type} p1 = \hyperref[Ocamlary-Aliases-P2-Z--type-t]{\ocamlinlinecode{X1.\allowbreak{}t}}}\\
742
755
\label{Ocamlary-Aliases--type-p2}\ocamlcodefragment{\ocamltag{keyword}{type} p2 = \hyperref[Ocamlary-Aliases-P2-Z--type-t]{\ocamlinlinecode{X2.\allowbreak{}t}}}\\
···
785
798
\end{ocamlindent}%
786
799
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
787
800
\label{Ocamlary--type-new_t}\ocamlcodefragment{\ocamltag{keyword}{type} new\_\allowbreak{}t = .\allowbreak{}.\allowbreak{}}\\
788
-
\label{Ocamlary--extension-decl-C}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-new_t]{\ocamlinlinecode{new\_\allowbreak{}t}} += }\\
801
+
\label{Ocamlary--extension-decl-C}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-new_t]{\ocamlinlinecode{Ocamlary.\allowbreak{}new\_\allowbreak{}t}} += }\\
789
802
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{C}}\label{Ocamlary--extension-C}\\
790
803
\end{ocamltabular}%
791
804
\\
792
-
\label{Ocamlary--module-type-TypeExtPruned}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-TypeExtPruned]{\ocamlinlinecode{TypeExtPruned}}}\label{Ocamlary-module-type-TypeExtPruned}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-TypeExtPruned--extension-decl-C}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-new_t]{\ocamlinlinecode{new\_\allowbreak{}t}} += }\\
805
+
\label{Ocamlary--module-type-TypeExtPruned}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Ocamlary-module-type-TypeExtPruned]{\ocamlinlinecode{TypeExtPruned}}}\label{Ocamlary-module-type-TypeExtPruned}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-module-type-TypeExtPruned--extension-decl-C}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Ocamlary--type-new_t]{\ocamlinlinecode{Ocamlary.\allowbreak{}new\_\allowbreak{}t}} += }\\
793
806
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{C}}\label{Ocamlary-module-type-TypeExtPruned--extension-C}\\
794
807
\end{ocamltabular}%
795
808
\\
796
-
\label{Ocamlary-module-type-TypeExtPruned--val-f}\ocamlcodefragment{\ocamltag{keyword}{val} f : \hyperref[Ocamlary--type-new_t]{\ocamlinlinecode{new\_\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} unit}\\
809
+
\label{Ocamlary-module-type-TypeExtPruned--val-f}\ocamlcodefragment{\ocamltag{keyword}{val} f : \hyperref[Ocamlary--type-new_t]{\ocamlinlinecode{Ocamlary.\allowbreak{}new\_\allowbreak{}t}} \ocamltag{arrow}{$\rightarrow$} unit}\\
797
810
\end{ocamlindent}%
798
811
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
799
812
\label{Ocamlary--module-Op}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Ocamlary-Op]{\ocamlinlinecode{Op}}}\label{Ocamlary-Op}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Ocamlary-Op--val-(let*)}\ocamlcodefragment{\ocamltag{keyword}{val} (let*) : int}\\
+28
odoc/test/generators/latex/Recent.tex
+28
odoc/test/generators/latex/Recent.tex
···
22
22
\ocamlcodefragment{\}}\label{Recent--type-variant.E}%
23
23
\begin{ocamlindent}\end{ocamlindent}%
24
24
\end{ocamlindent}%
25
+
<<<<<<< HEAD
25
26
\label{Recent--type-gadt}\ocamlcodefragment{\ocamltag{keyword}{type} \_\allowbreak{} gadt = }\begin{ocamlindent}\ocamlcodefragment{| \ocamltag{constructor}{A} : int \hyperref[Recent--type-gadt]{\ocamlinlinecode{gadt}}}\label{Recent--type-gadt.A}%
26
27
\begin{ocamlindent}\end{ocamlindent}%
27
28
\ocamlcodefragment{| \ocamltag{constructor}{B} : int \ocamltag{arrow}{$\rightarrow$} string \hyperref[Recent--type-gadt]{\ocamlinlinecode{gadt}}}\label{Recent--type-gadt.B}%
29
+
=======
30
+
\label{Recent-type-gadt}\ocamlcodefragment{\ocamltag{keyword}{type} \_\allowbreak{} gadt = }\begin{ocamlindent}\ocamlcodefragment{| \ocamltag{constructor}{A} : int \hyperref[Recent-type-gadt]{\ocamlinlinecode{Recent.\allowbreak{}gadt}}}\label{Recent-type-gadt.A}%
31
+
\begin{ocamlindent}\end{ocamlindent}%
32
+
\ocamlcodefragment{| \ocamltag{constructor}{B} : int \ocamltag{arrow}{$\rightarrow$} string \hyperref[Recent-type-gadt]{\ocamlinlinecode{Recent.\allowbreak{}gadt}}}\label{Recent-type-gadt.B}%
33
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
28
34
\begin{ocamlindent}foo\end{ocamlindent}%
29
35
\ocamlcodefragment{| \ocamltag{constructor}{C} : \{}\\
30
36
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{a : int;\allowbreak{}}\label{Recent--type-gadt.a}\\
31
37
\end{ocamltabular}%
32
38
\\
39
+
<<<<<<< HEAD
33
40
\ocamlcodefragment{\} \ocamltag{arrow}{$\rightarrow$} unit \hyperref[Recent--type-gadt]{\ocamlinlinecode{gadt}}}\label{Recent--type-gadt.C}%
41
+
=======
42
+
\ocamlcodefragment{\} \ocamltag{arrow}{$\rightarrow$} unit \hyperref[Recent-type-gadt]{\ocamlinlinecode{Recent.\allowbreak{}gadt}}}\label{Recent-type-gadt.C}%
43
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
34
44
\begin{ocamlindent}\end{ocamlindent}%
35
45
\end{ocamlindent}%
36
46
\label{Recent--type-polymorphic_variant}\ocamlcodefragment{\ocamltag{keyword}{type} polymorphic\_\allowbreak{}variant = [ }\\
···
41
51
\end{ocamltabular}%
42
52
\\
43
53
\ocamlcodefragment{ ]}\\
54
+
<<<<<<< HEAD
44
55
\label{Recent--type-empty_variant}\ocamlcodefragment{\ocamltag{keyword}{type} empty\_\allowbreak{}variant = |}\\
45
56
\label{Recent--type-nonrec_}\ocamlcodefragment{\ocamltag{keyword}{type} \ocamltag{keyword}{nonrec} nonrec\_\allowbreak{} = int}\\
46
57
\label{Recent--type-empty_conj}\ocamlcodefragment{\ocamltag{keyword}{type} empty\_\allowbreak{}conj = }\\
···
49
60
\\
50
61
\label{Recent--type-conj}\ocamlcodefragment{\ocamltag{keyword}{type} conj = }\\
51
62
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{X} : [< `X of int \& [< `B of int \& float ] ] \ocamltag{arrow}{$\rightarrow$} \hyperref[Recent--type-conj]{\ocamlinlinecode{conj}}}\label{Recent--type-conj.X}\\
63
+
=======
64
+
\label{Recent-type-empty_variant}\ocamlcodefragment{\ocamltag{keyword}{type} empty\_\allowbreak{}variant = |}\\
65
+
\label{Recent-type-nonrec_}\ocamlcodefragment{\ocamltag{keyword}{type} \ocamltag{keyword}{nonrec} nonrec\_\allowbreak{} = int}\\
66
+
\label{Recent-type-empty_conj}\ocamlcodefragment{\ocamltag{keyword}{type} empty\_\allowbreak{}conj = }\\
67
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{X} : [< `X of \& \ocamltag{type-var}{'a} \& int * float ] \ocamltag{arrow}{$\rightarrow$} \hyperref[Recent-type-empty_conj]{\ocamlinlinecode{Recent.\allowbreak{}empty\_\allowbreak{}conj}}}\label{Recent-type-empty_conj.X}\\
68
+
\end{ocamltabular}%
69
+
\\
70
+
\label{Recent-type-conj}\ocamlcodefragment{\ocamltag{keyword}{type} conj = }\\
71
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{X} : [< `X of int \& [< `B of int \& float ] ] \ocamltag{arrow}{$\rightarrow$} \hyperref[Recent-type-conj]{\ocamlinlinecode{Recent.\allowbreak{}conj}}}\label{Recent-type-conj.X}\\
72
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
52
73
\end{ocamltabular}%
53
74
\\
54
75
\label{Recent--val-empty_conj}\ocamlcodefragment{\ocamltag{keyword}{val} empty\_\allowbreak{}conj : [< `X of \& \ocamltag{type-var}{'a} \& int * float ]}\\
···
60
81
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
61
82
\end{ocamlindent}%
62
83
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
84
+
<<<<<<< HEAD
63
85
\label{Recent--module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Recent-X]{\ocamlinlinecode{X}}}\label{Recent-X}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Recent-X--module-L}\ocamlcodefragment{\ocamltag{keyword}{module} L := \hyperref[Recent-Z-Y]{\ocamlinlinecode{Z.\allowbreak{}Y}}}\\
64
86
\label{Recent-X--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = int \hyperref[Recent-Z-Y-X--type-t]{\ocamlinlinecode{L.\allowbreak{}X.\allowbreak{}t}}}\\
65
87
\label{Recent-X--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u := int}\\
66
88
\label{Recent-X--type-v}\ocamlcodefragment{\ocamltag{keyword}{type} v = \hyperref[Recent-X--type-u]{\ocamlinlinecode{u}} \hyperref[Recent-Z-Y-X--type-t]{\ocamlinlinecode{L.\allowbreak{}X.\allowbreak{}t}}}\\
89
+
=======
90
+
\label{Recent-module-X}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Recent-X]{\ocamlinlinecode{X}}}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Recent-X-module-L}\ocamlcodefragment{\ocamltag{keyword}{module} L := \hyperref[Recent-Z-Y]{\ocamlinlinecode{Recent.\allowbreak{}Z.\allowbreak{}Y}}}\\
91
+
\label{Recent-X-type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = int \hyperref[Recent-Z-Y-X-type-t]{\ocamlinlinecode{L.\allowbreak{}X.\allowbreak{}t}}}\\
92
+
\label{Recent-X-type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u := int}\\
93
+
\label{Recent-X-type-v}\ocamlcodefragment{\ocamltag{keyword}{type} v = \hyperref[Recent-X-type-u]{\ocamlinlinecode{Recent.\allowbreak{}X.\allowbreak{}u}} \hyperref[Recent-Z-Y-X-type-t]{\ocamlinlinecode{L.\allowbreak{}X.\allowbreak{}t}}}\\
94
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
67
95
\end{ocamlindent}%
68
96
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
69
97
\label{Recent--module-type-PolyS}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Recent-module-type-PolyS]{\ocamlinlinecode{PolyS}}}\label{Recent-module-type-PolyS}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\label{Recent-module-type-PolyS--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t = [ }\\
+1
-1
odoc/test/generators/latex/Recent_impl.tex
+1
-1
odoc/test/generators/latex/Recent_impl.tex
···
21
21
\label{Recent_impl-module-type-S--val-f}\ocamlcodefragment{\ocamltag{keyword}{val} f : \hyperref[Recent_impl-module-type-S-F--type-t]{\ocamlinlinecode{F(X).\allowbreak{}t}}}\\
22
22
\end{ocamlindent}%
23
23
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
24
-
\label{Recent_impl--module-B'}\ocamlcodefragment{\ocamltag{keyword}{module} B' = \hyperref[Recent_impl-Foo-B]{\ocamlinlinecode{Foo.\allowbreak{}B}}}\\
24
+
\label{Recent_impl--module-B'}\ocamlcodefragment{\ocamltag{keyword}{module} B' = \hyperref[Recent_impl-Foo-B]{\ocamlinlinecode{Recent\_\allowbreak{}impl.\allowbreak{}Foo.\allowbreak{}B}}}\\
25
25
26
26
\input{Recent_impl.B.tex}
+8
-8
odoc/test/generators/latex/Stop_dead_link_doc.tex
+8
-8
odoc/test/generators/latex/Stop_dead_link_doc.tex
···
3
3
\end{ocamlindent}%
4
4
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
5
5
\label{Stop_dead_link_doc--type-foo}\ocamlcodefragment{\ocamltag{keyword}{type} foo = }\\
6
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar} \ocamltag{keyword}{of} \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Foo.\allowbreak{}t}}}\label{Stop_dead_link_doc--type-foo.Bar}\\
6
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar} \ocamltag{keyword}{of} \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Foo.\allowbreak{}t}}}\label{Stop_dead_link_doc--type-foo.Bar}\\
7
7
\end{ocamltabular}%
8
8
\\
9
9
\label{Stop_dead_link_doc--type-bar}\ocamlcodefragment{\ocamltag{keyword}{type} bar = }\begin{ocamlindent}\ocamlcodefragment{| \ocamltag{constructor}{Bar} \ocamltag{keyword}{of} \{}\\
10
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{field : \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Foo.\allowbreak{}t}};\allowbreak{}}\label{Stop_dead_link_doc--type-bar.field}\\
10
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{field : \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Foo.\allowbreak{}t}};\allowbreak{}}\label{Stop_dead_link_doc--type-bar.field}\\
11
11
\end{ocamltabular}%
12
12
\\
13
13
\ocamlcodefragment{\}}\label{Stop_dead_link_doc--type-bar.Bar}\\
14
14
\end{ocamlindent}%
15
15
\label{Stop_dead_link_doc--type-foo_}\ocamlcodefragment{\ocamltag{keyword}{type} foo\_\allowbreak{} = }\\
16
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}} \ocamltag{keyword}{of} int * \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Foo.\allowbreak{}t}} * int}\label{Stop_dead_link_doc--type-foo_.Bar_}\\
16
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}} \ocamltag{keyword}{of} int * \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Foo.\allowbreak{}t}} * int}\label{Stop_dead_link_doc--type-foo_.Bar_}\\
17
17
\end{ocamltabular}%
18
18
\\
19
19
\label{Stop_dead_link_doc--type-bar_}\ocamlcodefragment{\ocamltag{keyword}{type} bar\_\allowbreak{} = }\\
20
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}\_\allowbreak{}} \ocamltag{keyword}{of} \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Foo.\allowbreak{}t}} option}\label{Stop_dead_link_doc--type-bar_.Bar__}\\
20
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}\_\allowbreak{}} \ocamltag{keyword}{of} \hyperref[Stop_dead_link_doc-Foo--type-t]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Foo.\allowbreak{}t}} option}\label{Stop_dead_link_doc--type-bar_.Bar__}\\
21
21
\end{ocamltabular}%
22
22
\\
23
23
\label{Stop_dead_link_doc--type-another_foo}\ocamlcodefragment{\ocamltag{keyword}{type} another\_\allowbreak{}foo = }\\
24
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar} \ocamltag{keyword}{of} \hyperref[xref-unresolved]{\ocamlinlinecode{Another\_\allowbreak{}Foo.\allowbreak{}t}}}\label{Stop_dead_link_doc--type-another_foo.Bar}\\
24
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar} \ocamltag{keyword}{of} \hyperref[xref-unresolved]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Another\_\allowbreak{}Foo.\allowbreak{}t}}}\label{Stop_dead_link_doc--type-another_foo.Bar}\\
25
25
\end{ocamltabular}%
26
26
\\
27
27
\label{Stop_dead_link_doc--type-another_bar}\ocamlcodefragment{\ocamltag{keyword}{type} another\_\allowbreak{}bar = }\begin{ocamlindent}\ocamlcodefragment{| \ocamltag{constructor}{Bar} \ocamltag{keyword}{of} \{}\\
28
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{field : \hyperref[xref-unresolved]{\ocamlinlinecode{Another\_\allowbreak{}Foo.\allowbreak{}t}};\allowbreak{}}\label{Stop_dead_link_doc--type-another_bar.field}\\
28
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{field : \hyperref[xref-unresolved]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Another\_\allowbreak{}Foo.\allowbreak{}t}};\allowbreak{}}\label{Stop_dead_link_doc--type-another_bar.field}\\
29
29
\end{ocamltabular}%
30
30
\\
31
31
\ocamlcodefragment{\}}\label{Stop_dead_link_doc--type-another_bar.Bar}\\
32
32
\end{ocamlindent}%
33
33
\label{Stop_dead_link_doc--type-another_foo_}\ocamlcodefragment{\ocamltag{keyword}{type} another\_\allowbreak{}foo\_\allowbreak{} = }\\
34
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}} \ocamltag{keyword}{of} int * \hyperref[xref-unresolved]{\ocamlinlinecode{Another\_\allowbreak{}Foo.\allowbreak{}t}} * int}\label{Stop_dead_link_doc--type-another_foo_.Bar_}\\
34
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}} \ocamltag{keyword}{of} int * \hyperref[xref-unresolved]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Another\_\allowbreak{}Foo.\allowbreak{}t}} * int}\label{Stop_dead_link_doc--type-another_foo_.Bar_}\\
35
35
\end{ocamltabular}%
36
36
\\
37
37
\label{Stop_dead_link_doc--type-another_bar_}\ocamlcodefragment{\ocamltag{keyword}{type} another\_\allowbreak{}bar\_\allowbreak{} = }\\
38
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}\_\allowbreak{}} \ocamltag{keyword}{of} \hyperref[xref-unresolved]{\ocamlinlinecode{Another\_\allowbreak{}Foo.\allowbreak{}t}} option}\label{Stop_dead_link_doc--type-another_bar_.Bar__}\\
38
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{Bar\_\allowbreak{}\_\allowbreak{}} \ocamltag{keyword}{of} \hyperref[xref-unresolved]{\ocamlinlinecode{Stop\_\allowbreak{}dead\_\allowbreak{}link\_\allowbreak{}doc.\allowbreak{}Another\_\allowbreak{}Foo.\allowbreak{}t}} option}\label{Stop_dead_link_doc--type-another_bar_.Bar__}\\
39
39
\end{ocamltabular}%
40
40
\\
41
41
+5
-5
odoc/test/generators/latex/Toplevel_comments.tex
+5
-5
odoc/test/generators/latex/Toplevel_comments.tex
···
5
5
\end{ocamlindent}%
6
6
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{T}, part 1.\end{ocamlindent}%
7
7
\medbreak
8
-
\label{Toplevel_comments--module-Include_inline}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-Include_inline]{\ocamlinlinecode{Include\_\allowbreak{}inline}}}\label{Toplevel_comments-Include_inline}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{T}}\label{Toplevel_comments-Include_inline--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
8
+
\label{Toplevel_comments--module-Include_inline}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-Include_inline]{\ocamlinlinecode{Include\_\allowbreak{}inline}}}\label{Toplevel_comments-Include_inline}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{Toplevel\_\allowbreak{}comments.\allowbreak{}T}}\label{Toplevel_comments-Include_inline--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
9
9
\end{ocamlindent}%
10
10
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{T}, part 2.\end{ocamlindent}%
11
11
\medbreak
12
-
\label{Toplevel_comments--module-Include_inline'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-Include_inline']{\ocamlinlinecode{Include\_\allowbreak{}inline'}}}\label{Toplevel_comments-Include_inline'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}part 3\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{T}}\label{Toplevel_comments-Include_inline'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
12
+
\label{Toplevel_comments--module-Include_inline'}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-Include_inline']{\ocamlinlinecode{Include\_\allowbreak{}inline'}}}\label{Toplevel_comments-Include_inline'}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}part 3\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{Toplevel\_\allowbreak{}comments.\allowbreak{}T}}\label{Toplevel_comments-Include_inline'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
13
13
\end{ocamlindent}%
14
14
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{Include\_\allowbreak{}inline}, part 1.\end{ocamlindent}%
15
15
\medbreak
16
-
\label{Toplevel_comments--module-type-Include_inline_T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Toplevel_comments-module-type-Include_inline_T]{\ocamlinlinecode{Include\_\allowbreak{}inline\_\allowbreak{}T}}}\label{Toplevel_comments-module-type-Include_inline_T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{T}}\label{Toplevel_comments-module-type-Include_inline_T--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
16
+
\label{Toplevel_comments--module-type-Include_inline_T}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Toplevel_comments-module-type-Include_inline_T]{\ocamlinlinecode{Include\_\allowbreak{}inline\_\allowbreak{}T}}}\label{Toplevel_comments-module-type-Include_inline_T}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{Toplevel\_\allowbreak{}comments.\allowbreak{}T}}\label{Toplevel_comments-module-type-Include_inline_T--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
17
17
\end{ocamlindent}%
18
18
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{T}, part 2.\end{ocamlindent}%
19
19
\medbreak
20
-
\label{Toplevel_comments--module-type-Include_inline_T'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Toplevel_comments-module-type-Include_inline_T']{\ocamlinlinecode{Include\_\allowbreak{}inline\_\allowbreak{}T'}}}\label{Toplevel_comments-module-type-Include_inline_T'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}part 3\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{T}}\label{Toplevel_comments-module-type-Include_inline_T'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
20
+
\label{Toplevel_comments--module-type-Include_inline_T'}\ocamlcodefragment{\ocamltag{keyword}{module} \ocamltag{keyword}{type} \hyperref[Toplevel_comments-module-type-Include_inline_T']{\ocamlinlinecode{Include\_\allowbreak{}inline\_\allowbreak{}T'}}}\label{Toplevel_comments-module-type-Include_inline_T'}\ocamlcodefragment{ = \ocamltag{keyword}{sig}}\begin{ocamlindent}part 3\ocamltag{keyword}{include} \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{Toplevel\_\allowbreak{}comments.\allowbreak{}T}}\label{Toplevel_comments-module-type-Include_inline_T'--type-t}\ocamlcodefragment{\ocamltag{keyword}{type} t}\\
21
21
\end{ocamlindent}%
22
22
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{Include\_\allowbreak{}inline\_\allowbreak{}T'}, part 1.\end{ocamlindent}%
23
23
\medbreak
···
30
30
\label{Toplevel_comments--module-M''}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-M'']{\ocamlinlinecode{M''}}}\label{Toplevel_comments-M''}\ocamlcodefragment{ : \ocamltag{keyword}{sig}}\begin{ocamlindent}\end{ocamlindent}%
31
31
\ocamlcodefragment{\ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{M''}, part 1.\end{ocamlindent}%
32
32
\medbreak
33
-
\label{Toplevel_comments--module-Alias}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-Alias]{\ocamlinlinecode{Alias}}}\ocamlcodefragment{ : \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{T}}}\begin{ocamlindent}Doc of \ocamlinlinecode{Alias}.\end{ocamlindent}%
33
+
\label{Toplevel_comments--module-Alias}\ocamlcodefragment{\ocamltag{keyword}{module} \hyperref[Toplevel_comments-Alias]{\ocamlinlinecode{Alias}}}\ocamlcodefragment{ : \hyperref[Toplevel_comments-module-type-T]{\ocamlinlinecode{Toplevel\_\allowbreak{}comments.\allowbreak{}T}}}\begin{ocamlindent}Doc of \ocamlinlinecode{Alias}.\end{ocamlindent}%
34
34
\medbreak
35
35
\label{Toplevel_comments--class-c1}\ocamlcodefragment{\ocamltag{keyword}{class} \hyperref[Toplevel_comments-class-c1]{\ocamlinlinecode{c1}}}\ocamlcodefragment{ : int \ocamltag{arrow}{$\rightarrow$} \ocamltag{keyword}{object} .\allowbreak{}.\allowbreak{}.\allowbreak{} \ocamltag{keyword}{end}}\begin{ocamlindent}Doc of \ocamlinlinecode{c1}, part 1.\end{ocamlindent}%
36
36
\medbreak
+23
-23
odoc/test/generators/latex/Type.tex
+23
-23
odoc/test/generators/latex/Type.tex
···
13
13
\label{Type--type-parens_dropped}\ocamlcodefragment{\ocamltag{keyword}{type} parens\_\allowbreak{}dropped = int * int}\\
14
14
\label{Type--type-triple}\ocamlcodefragment{\ocamltag{keyword}{type} triple = int * int * int}\\
15
15
\label{Type--type-nested_pair}\ocamlcodefragment{\ocamltag{keyword}{type} nested\_\allowbreak{}pair = (int * int) * int}\\
16
-
\label{Type--type-instance}\ocamlcodefragment{\ocamltag{keyword}{type} instance = int \hyperref[Type--type-constructor]{\ocamlinlinecode{constructor}}}\\
16
+
\label{Type--type-instance}\ocamlcodefragment{\ocamltag{keyword}{type} instance = int \hyperref[Type--type-constructor]{\ocamlinlinecode{Type.\allowbreak{}constructor}}}\\
17
17
\label{Type--type-long}\ocamlcodefragment{\ocamltag{keyword}{type} long =
18
-
\hyperref[Type--type-labeled_higher_order]{\ocamlinlinecode{labeled\_\allowbreak{}higher\_\allowbreak{}order}} \ocamltag{arrow}{$\rightarrow$}
19
-
[ `Bar | `Baz of \hyperref[Type--type-triple]{\ocamlinlinecode{triple}} ] \ocamltag{arrow}{$\rightarrow$}
20
-
\hyperref[Type--type-pair]{\ocamlinlinecode{pair}} \ocamltag{arrow}{$\rightarrow$}
21
-
\hyperref[Type--type-labeled]{\ocamlinlinecode{labeled}} \ocamltag{arrow}{$\rightarrow$}
22
-
\hyperref[Type--type-higher_order]{\ocamlinlinecode{higher\_\allowbreak{}order}} \ocamltag{arrow}{$\rightarrow$}
18
+
\hyperref[Type--type-labeled_higher_order]{\ocamlinlinecode{Type.\allowbreak{}labeled\_\allowbreak{}higher\_\allowbreak{}order}} \ocamltag{arrow}{$\rightarrow$}
19
+
[ `Bar | `Baz of \hyperref[Type--type-triple]{\ocamlinlinecode{Type.\allowbreak{}triple}} ] \ocamltag{arrow}{$\rightarrow$}
20
+
\hyperref[Type--type-pair]{\ocamlinlinecode{Type.\allowbreak{}pair}} \ocamltag{arrow}{$\rightarrow$}
21
+
\hyperref[Type--type-labeled]{\ocamlinlinecode{Type.\allowbreak{}labeled}} \ocamltag{arrow}{$\rightarrow$}
22
+
\hyperref[Type--type-higher_order]{\ocamlinlinecode{Type.\allowbreak{}higher\_\allowbreak{}order}} \ocamltag{arrow}{$\rightarrow$}
23
23
(string \ocamltag{arrow}{$\rightarrow$} int) \ocamltag{arrow}{$\rightarrow$}
24
24
(int * float * char * string * char * unit) option \ocamltag{arrow}{$\rightarrow$}
25
-
\hyperref[Type--type-nested_pair]{\ocamlinlinecode{nested\_\allowbreak{}pair}} \ocamltag{arrow}{$\rightarrow$}
26
-
\hyperref[Type--type-arrow]{\ocamlinlinecode{arrow}} \ocamltag{arrow}{$\rightarrow$}
25
+
\hyperref[Type--type-nested_pair]{\ocamlinlinecode{Type.\allowbreak{}nested\_\allowbreak{}pair}} \ocamltag{arrow}{$\rightarrow$}
26
+
\hyperref[Type--type-arrow]{\ocamlinlinecode{Type.\allowbreak{}arrow}} \ocamltag{arrow}{$\rightarrow$}
27
27
string \ocamltag{arrow}{$\rightarrow$}
28
-
\hyperref[Type--type-nested_pair]{\ocamlinlinecode{nested\_\allowbreak{}pair}} array}\\
28
+
\hyperref[Type--type-nested_pair]{\ocamlinlinecode{Type.\allowbreak{}nested\_\allowbreak{}pair}} array}\\
29
29
\label{Type--type-variant_e}\ocamlcodefragment{\ocamltag{keyword}{type} variant\_\allowbreak{}e = \{}\\
30
30
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlinlinecode{a : int;\allowbreak{}}\label{Type--type-variant_e.a}\\
31
31
\end{ocamltabular}%
···
36
36
\ocamlcodefragment{| \ocamltag{constructor}{B} \ocamltag{keyword}{of} int}\label{Type--type-variant.B}& \\
37
37
\ocamlcodefragment{| \ocamltag{constructor}{C}}\label{Type--type-variant.C}& foo\\
38
38
\ocamlcodefragment{| \ocamltag{constructor}{D}}\label{Type--type-variant.D}& \emph{bar}\\
39
-
\ocamlcodefragment{| \ocamltag{constructor}{E} \ocamltag{keyword}{of} \hyperref[Type--type-variant_e]{\ocamlinlinecode{variant\_\allowbreak{}e}}}\label{Type--type-variant.E}& \\
39
+
\ocamlcodefragment{| \ocamltag{constructor}{E} \ocamltag{keyword}{of} \hyperref[Type--type-variant_e]{\ocamlinlinecode{Type.\allowbreak{}variant\_\allowbreak{}e}}}\label{Type--type-variant.E}& \\
40
40
\end{ocamltabular}%
41
41
\\
42
42
\label{Type--type-variant_c}\ocamlcodefragment{\ocamltag{keyword}{type} variant\_\allowbreak{}c = \{}\\
···
45
45
\\
46
46
\ocamlcodefragment{\}}\\
47
47
\label{Type--type-gadt}\ocamlcodefragment{\ocamltag{keyword}{type} \_\allowbreak{} gadt = }\\
48
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A} : int \hyperref[Type--type-gadt]{\ocamlinlinecode{gadt}}}\label{Type--type-gadt.A}\\
49
-
\ocamlcodefragment{| \ocamltag{constructor}{B} : int \ocamltag{arrow}{$\rightarrow$} string \hyperref[Type--type-gadt]{\ocamlinlinecode{gadt}}}\label{Type--type-gadt.B}\\
50
-
\ocamlcodefragment{| \ocamltag{constructor}{C} : \hyperref[Type--type-variant_c]{\ocamlinlinecode{variant\_\allowbreak{}c}} \ocamltag{arrow}{$\rightarrow$} unit \hyperref[Type--type-gadt]{\ocamlinlinecode{gadt}}}\label{Type--type-gadt.C}\\
48
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A} : int \hyperref[Type--type-gadt]{\ocamlinlinecode{Type.\allowbreak{}gadt}}}\label{Type--type-gadt.A}\\
49
+
\ocamlcodefragment{| \ocamltag{constructor}{B} : int \ocamltag{arrow}{$\rightarrow$} string \hyperref[Type--type-gadt]{\ocamlinlinecode{Type.\allowbreak{}gadt}}}\label{Type--type-gadt.B}\\
50
+
\ocamlcodefragment{| \ocamltag{constructor}{C} : \hyperref[Type--type-variant_c]{\ocamlinlinecode{Type.\allowbreak{}variant\_\allowbreak{}c}} \ocamltag{arrow}{$\rightarrow$} unit \hyperref[Type--type-gadt]{\ocamlinlinecode{Type.\allowbreak{}gadt}}}\label{Type--type-gadt.C}\\
51
51
\end{ocamltabular}%
52
52
\\
53
53
\label{Type--type-degenerate_gadt}\ocamlcodefragment{\ocamltag{keyword}{type} degenerate\_\allowbreak{}gadt = }\\
54
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A} : \hyperref[Type--type-degenerate_gadt]{\ocamlinlinecode{degenerate\_\allowbreak{}gadt}}}\label{Type--type-degenerate_gadt.A}\\
54
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A} : \hyperref[Type--type-degenerate_gadt]{\ocamlinlinecode{Type.\allowbreak{}degenerate\_\allowbreak{}gadt}}}\label{Type--type-degenerate_gadt.A}\\
55
55
\end{ocamltabular}%
56
56
\\
57
57
\label{Type--type-private_variant}\ocamlcodefragment{\ocamltag{keyword}{type} private\_\allowbreak{}variant = \ocamltag{keyword}{private} }\\
···
76
76
\\
77
77
\ocamlcodefragment{ ]}\\
78
78
\label{Type--type-polymorphic_variant_extension}\ocamlcodefragment{\ocamltag{keyword}{type} polymorphic\_\allowbreak{}variant\_\allowbreak{}extension = [ }\\
79
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \hyperref[Type--type-polymorphic_variant]{\ocamlinlinecode{polymorphic\_\allowbreak{}variant}}}\label{Type--type-polymorphic_variant_extension.polymorphic_variant}\\
79
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \hyperref[Type--type-polymorphic_variant]{\ocamlinlinecode{Type.\allowbreak{}polymorphic\_\allowbreak{}variant}}}\label{Type--type-polymorphic_variant_extension.Type.polymorphic_variant}\\
80
80
\ocamlcodefragment{| `E}\label{Type--type-polymorphic_variant_extension.E}\\
81
81
\end{ocamltabular}%
82
82
\\
···
87
87
\\
88
88
\ocamlcodefragment{ ]}\\
89
89
\label{Type--type-private_extenion}\ocamlcodefragment{\ocamltag{keyword}{type} private\_\allowbreak{}extenion = \ocamltag{keyword}{private} [> }\\
90
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \hyperref[Type--type-polymorphic_variant]{\ocamlinlinecode{polymorphic\_\allowbreak{}variant}}}\label{Type--type-private_extenion.polymorphic_variant}\\
90
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \hyperref[Type--type-polymorphic_variant]{\ocamlinlinecode{Type.\allowbreak{}polymorphic\_\allowbreak{}variant}}}\label{Type--type-private_extenion.Type.polymorphic_variant}\\
91
91
\end{ocamltabular}%
92
92
\\
93
93
\ocamlcodefragment{ ]}\\
···
96
96
\label{Type-module-type-X--type-u}\ocamlcodefragment{\ocamltag{keyword}{type} u}\\
97
97
\end{ocamlindent}%
98
98
\ocamlcodefragment{\ocamltag{keyword}{end}}\\
99
-
\label{Type--type-module_}\ocamlcodefragment{\ocamltag{keyword}{type} module\_\allowbreak{} = (\ocamltag{keyword}{module} \hyperref[Type-module-type-X]{\ocamlinlinecode{X}})}\\
100
-
\label{Type--type-module_substitution}\ocamlcodefragment{\ocamltag{keyword}{type} module\_\allowbreak{}substitution = (\ocamltag{keyword}{module} \hyperref[Type-module-type-X]{\ocamlinlinecode{X}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Type-module-type-X--type-t]{\ocamlinlinecode{t}} = int \ocamltag{keyword}{and} \ocamltag{keyword}{type} \hyperref[Type-module-type-X--type-u]{\ocamlinlinecode{u}} = unit)}\\
99
+
\label{Type--type-module_}\ocamlcodefragment{\ocamltag{keyword}{type} module\_\allowbreak{} = (\ocamltag{keyword}{module} \hyperref[Type-module-type-X]{\ocamlinlinecode{Type.\allowbreak{}X}})}\\
100
+
\label{Type--type-module_substitution}\ocamlcodefragment{\ocamltag{keyword}{type} module\_\allowbreak{}substitution = (\ocamltag{keyword}{module} \hyperref[Type-module-type-X]{\ocamlinlinecode{Type.\allowbreak{}X}} \ocamltag{keyword}{with} \ocamltag{keyword}{type} \hyperref[Type-module-type-X--type-t]{\ocamlinlinecode{t}} = int \ocamltag{keyword}{and} \ocamltag{keyword}{type} \hyperref[Type-module-type-X--type-u]{\ocamlinlinecode{u}} = unit)}\\
101
101
\label{Type--type-covariant}\ocamlcodefragment{\ocamltag{keyword}{type} +'a covariant}\\
102
102
\label{Type--type-contravariant}\ocamlcodefragment{\ocamltag{keyword}{type} -'a contravariant}\\
103
103
\label{Type--type-bivariant}\ocamlcodefragment{\ocamltag{keyword}{type} \_\allowbreak{} bivariant = int}\\
104
104
\label{Type--type-binary}\ocamlcodefragment{\ocamltag{keyword}{type} ('a,\allowbreak{} 'b) binary}\\
105
-
\label{Type--type-using_binary}\ocamlcodefragment{\ocamltag{keyword}{type} using\_\allowbreak{}binary = (int,\allowbreak{} int) \hyperref[Type--type-binary]{\ocamlinlinecode{binary}}}\\
105
+
\label{Type--type-using_binary}\ocamlcodefragment{\ocamltag{keyword}{type} using\_\allowbreak{}binary = (int,\allowbreak{} int) \hyperref[Type--type-binary]{\ocamlinlinecode{Type.\allowbreak{}binary}}}\\
106
106
\label{Type--type-name}\ocamlcodefragment{\ocamltag{keyword}{type} 'custom name}\\
107
107
\label{Type--type-constrained}\ocamlcodefragment{\ocamltag{keyword}{type} 'a constrained = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = int}\\
108
108
\label{Type--type-exact_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a exact\_\allowbreak{}variant = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [ `A | `B of int ]}\\
109
109
\label{Type--type-lower_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a lower\_\allowbreak{}variant = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [> `A | `B of int ]}\\
110
110
\label{Type--type-any_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a any\_\allowbreak{}variant = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [> ]}\\
111
111
\label{Type--type-upper_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a upper\_\allowbreak{}variant = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [< `A | `B of int ]}\\
112
-
\label{Type--type-named_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a named\_\allowbreak{}variant = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [< \hyperref[Type--type-polymorphic_variant]{\ocamlinlinecode{polymorphic\_\allowbreak{}variant}} ]}\\
112
+
\label{Type--type-named_variant}\ocamlcodefragment{\ocamltag{keyword}{type} 'a named\_\allowbreak{}variant = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = [< \hyperref[Type--type-polymorphic_variant]{\ocamlinlinecode{Type.\allowbreak{}polymorphic\_\allowbreak{}variant}} ]}\\
113
113
\label{Type--type-exact_object}\ocamlcodefragment{\ocamltag{keyword}{type} 'a exact\_\allowbreak{}object = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = < a : int ;\allowbreak{} b : int >}\\
114
114
\label{Type--type-lower_object}\ocamlcodefragment{\ocamltag{keyword}{type} 'a lower\_\allowbreak{}object = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = < a : int ;\allowbreak{} b : int.\allowbreak{}.\allowbreak{} >}\\
115
115
\label{Type--type-poly_object}\ocamlcodefragment{\ocamltag{keyword}{type} 'a poly\_\allowbreak{}object = \ocamltag{type-var}{'a} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = < a : 'a.\allowbreak{} \ocamltag{type-var}{'a} >}\\
116
116
\label{Type--type-double_constrained}\ocamlcodefragment{\ocamltag{keyword}{type} ('a,\allowbreak{} 'b) double\_\allowbreak{}constrained = \ocamltag{type-var}{'a} * \ocamltag{type-var}{'b} \ocamltag{keyword}{constraint} \ocamltag{type-var}{'a} = int \ocamltag{keyword}{constraint} \ocamltag{type-var}{'b} = unit}\\
117
117
\label{Type--type-as_}\ocamlcodefragment{\ocamltag{keyword}{type} as\_\allowbreak{} = (int \ocamltag{keyword}{as} 'a) * \ocamltag{type-var}{'a}}\\
118
118
\label{Type--type-extensible}\ocamlcodefragment{\ocamltag{keyword}{type} extensible = .\allowbreak{}.\allowbreak{}}\\
119
-
\label{Type--extension-decl-Extension}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Type--type-extensible]{\ocamlinlinecode{extensible}} += }\\
119
+
\label{Type--extension-decl-Extension}\ocamlcodefragment{\ocamltag{keyword}{type} \hyperref[Type--type-extensible]{\ocamlinlinecode{Type.\allowbreak{}extensible}} += }\\
120
120
\begin{ocamltabular}{p{0.500\textwidth}p{0.500\textwidth}}\ocamlcodefragment{| \ocamltag{extension}{Extension}}\label{Type--extension-Extension}& Documentation for \hyperref[Type--extension-Extension]{\ocamlinlinecode{\ocamlinlinecode{Extension}}[p\pageref*{Type--extension-Extension}]}.\\
121
121
\ocamlcodefragment{| \ocamltag{extension}{Another\_\allowbreak{}extension}}\label{Type--extension-Another_extension}& Documentation for \hyperref[Type--extension-Another_extension]{\ocamlinlinecode{\ocamlinlinecode{Another\_\allowbreak{}extension}}[p\pageref*{Type--extension-Another_extension}]}.\\
122
122
\end{ocamltabular}%
123
123
\\
124
124
\label{Type--type-mutually}\ocamlcodefragment{\ocamltag{keyword}{type} mutually = }\\
125
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A} \ocamltag{keyword}{of} \hyperref[Type--type-recursive]{\ocamlinlinecode{recursive}}}\label{Type--type-mutually.A}\\
125
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{A} \ocamltag{keyword}{of} \hyperref[Type--type-recursive]{\ocamlinlinecode{Type.\allowbreak{}recursive}}}\label{Type--type-mutually.A}\\
126
126
\end{ocamltabular}%
127
127
\\
128
128
\label{Type--type-recursive}\ocamlcodefragment{\ocamltag{keyword}{and} recursive = }\\
129
-
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{B} \ocamltag{keyword}{of} \hyperref[Type--type-mutually]{\ocamlinlinecode{mutually}}}\label{Type--type-recursive.B}\\
129
+
\begin{ocamltabular}{p{1.000\textwidth}}\ocamlcodefragment{| \ocamltag{constructor}{B} \ocamltag{keyword}{of} \hyperref[Type--type-mutually]{\ocamlinlinecode{Type.\allowbreak{}mutually}}}\label{Type--type-recursive.B}\\
130
130
\end{ocamltabular}%
131
131
\\
132
132
\label{Type--exception-Foo}\ocamlcodefragment{\ocamltag{keyword}{exception} \ocamltag{exception}{Foo} \ocamltag{keyword}{of} int * int}\\
+5
-5
odoc/test/generators/man/Functor.3o
+5
-5
odoc/test/generators/man/Functor.3o
···
42
42
.br
43
43
\f[CB]end\fR
44
44
.sp
45
-
\f[CB]module\fR F1 (Arg : S) : S
45
+
\f[CB]module\fR F1 (Arg : Functor\.S) : Functor\.S
46
46
.sp
47
-
\f[CB]module\fR F2 (Arg : S) : S \f[CB]with\fR \f[CB]type\fR t = Arg\.t
47
+
\f[CB]module\fR F2 (Arg : Functor\.S) : Functor\.S \f[CB]with\fR \f[CB]type\fR t = Arg\.t
48
48
.sp
49
-
\f[CB]module\fR F3 (Arg : S) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
49
+
\f[CB]module\fR F3 (Arg : Functor\.S) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
50
50
.sp
51
-
\f[CB]module\fR F4 (Arg : S) : S
51
+
\f[CB]module\fR F4 (Arg : Functor\.S) : Functor\.S
52
52
.sp
53
-
\f[CB]module\fR F5 () : S
53
+
\f[CB]module\fR F5 () : Functor\.S
+1
-1
odoc/test/generators/man/Functor2.3o
+1
-1
odoc/test/generators/man/Functor2.3o
+1
-1
odoc/test/generators/man/Functor_ml.Foo'.3o
+1
-1
odoc/test/generators/man/Functor_ml.Foo'.3o
+4
-4
odoc/test/generators/man/Include.3o
+4
-4
odoc/test/generators/man/Include.3o
···
36
36
.br
37
37
\f[CB]end\fR
38
38
.sp
39
-
\f[CB]include\fR Not_inlined_and_closed
39
+
\f[CB]include\fR Include\.Not_inlined_and_closed
40
40
.sp
41
41
\f[CB]module\fR \f[CB]type\fR Not_inlined_and_opened = \f[CB]sig\fR
42
42
.br
···
50
50
\f[CB]module\fR \f[CB]type\fR Inherent_Module = \f[CB]sig\fR
51
51
.br
52
52
.ti +2
53
-
\f[CB]val\fR a : t
53
+
\f[CB]val\fR a : Include\.t
54
54
.br
55
55
\f[CB]end\fR
56
56
.sp
···
59
59
.ti +2
60
60
.sp
61
61
.ti +2
62
-
\f[CB]val\fR a : u
62
+
\f[CB]val\fR a : Include\.u
63
63
.br
64
64
\f[CB]end\fR
65
65
.sp
66
-
\f[CB]val\fR a : u
66
+
\f[CB]val\fR a : Include\.u
+1
-1
odoc/test/generators/man/Include2.Y_include_doc.3o
+1
-1
odoc/test/generators/man/Include2.Y_include_doc.3o
+1
-1
odoc/test/generators/man/Include2.Y_include_synopsis.3o
+1
-1
odoc/test/generators/man/Include2.Y_include_synopsis.3o
+6
-6
odoc/test/generators/man/Labels.3o
+6
-6
odoc/test/generators/man/Labels.3o
···
29
29
Attached to type
30
30
.nf
31
31
.sp
32
-
\f[CB]val\fR f : t
32
+
\f[CB]val\fR f : Labels\.t
33
33
.fi
34
34
.br
35
35
.ti +2
36
36
Attached to value
37
37
.nf
38
38
.sp
39
-
\f[CB]val\fR e : unit \f[CB]\->\fR t
39
+
\f[CB]val\fR e : unit \f[CB]\->\fR Labels\.t
40
40
.fi
41
41
.br
42
42
.ti +2
···
78
78
.sp
79
79
\f[CB]type\fR x = \.\.
80
80
.sp
81
-
\f[CB]type\fR x +=
81
+
\f[CB]type\fR Labels\.x +=
82
82
.br
83
83
.ti +2
84
84
| \f[CB]X\fR
···
89
89
Attached to extension
90
90
.nf
91
91
.sp
92
-
\f[CB]module\fR S := A
92
+
\f[CB]module\fR S := Labels\.A
93
93
.fi
94
94
.br
95
95
.ti +2
96
96
Attached to module subst
97
97
.nf
98
98
.sp
99
-
\f[CB]type\fR s := t
99
+
\f[CB]type\fR s := Labels\.t
100
100
.fi
101
101
.br
102
102
.ti +2
···
115
115
\f[CB]type\fR v = {
116
116
.br
117
117
.ti +2
118
-
f : t;
118
+
f : Labels\.t;
119
119
.br
120
120
.ti +4
121
121
(* Attached to field *)
+2
-2
odoc/test/generators/man/Module.3o
+2
-2
odoc/test/generators/man/Module.3o
···
46
46
.sp
47
47
\f[CB]module\fR \f[CB]type\fR S1
48
48
.sp
49
-
\f[CB]module\fR \f[CB]type\fR S2 = S
49
+
\f[CB]module\fR \f[CB]type\fR S2 = Module\.S
50
50
.sp
51
51
\f[CB]module\fR \f[CB]type\fR S3 = \f[CB]sig\fR
52
52
.br
···
134
134
\f[CB]type\fR ('a, 'b) w
135
135
.sp
136
136
.ti +2
137
-
\f[CB]module\fR M = M'
137
+
\f[CB]module\fR M = Module\.M'
138
138
.br
139
139
\f[CB]end\fR
140
140
.sp
+2
-2
odoc/test/generators/man/Module_type_alias.3o
+2
-2
odoc/test/generators/man/Module_type_alias.3o
···
45
45
.br
46
46
\f[CB]end\fR
47
47
.sp
48
-
\f[CB]module\fR \f[CB]type\fR D = A
48
+
\f[CB]module\fR \f[CB]type\fR D = Module_type_alias\.A
49
49
.sp
50
50
\f[CB]module\fR \f[CB]type\fR E = \f[CB]sig\fR
51
51
.br
···
104
104
.br
105
105
\f[CB]end\fR
106
106
.sp
107
-
\f[CB]module\fR \f[CB]type\fR I = B
107
+
\f[CB]module\fR \f[CB]type\fR I = Module_type_alias\.B
+1
-1
odoc/test/generators/man/Module_type_of.3o
+1
-1
odoc/test/generators/man/Module_type_of.3o
+1
-1
odoc/test/generators/man/Module_type_of.T.3o
+1
-1
odoc/test/generators/man/Module_type_of.T.3o
+2
-2
odoc/test/generators/man/Module_type_subst.Basic.3o
+2
-2
odoc/test/generators/man/Module_type_subst.Basic.3o
···
21
21
\f[CB]module\fR \f[CB]type\fR with_ = \f[CB]sig\fR
22
22
.br
23
23
.ti +2
24
-
\f[CB]module\fR \f[CB]type\fR T = s
24
+
\f[CB]module\fR \f[CB]type\fR T = Module_type_subst\.s
25
25
.br
26
26
\f[CB]end\fR
27
27
.sp
···
48
48
\f[CB]module\fR \f[CB]type\fR a = \f[CB]sig\fR
49
49
.br
50
50
.ti +2
51
-
\f[CB]module\fR \f[CB]type\fR b = s
51
+
\f[CB]module\fR \f[CB]type\fR b = Module_type_subst\.s
52
52
.sp
53
53
.ti +2
54
54
\f[CB]module\fR M : \f[CB]sig\fR \f[CB]end\fR
+2
-2
odoc/test/generators/man/Module_type_subst.Local.3o
+2
-2
odoc/test/generators/man/Module_type_subst.Local.3o
···
16
16
\f[CB]module\fR \f[CB]type\fR local = \f[CB]sig\fR
17
17
.br
18
18
.ti +2
19
-
\f[CB]type\fR t = local
19
+
\f[CB]type\fR t = Module_type_subst\.Local\.local
20
20
.br
21
21
\f[CB]end\fR
22
22
.sp
23
-
\f[CB]module\fR \f[CB]type\fR w = local
23
+
\f[CB]module\fR \f[CB]type\fR w = Module_type_subst\.Local\.local
24
24
.sp
25
25
\f[CB]module\fR \f[CB]type\fR s = \f[CB]sig\fR \f[CB]end\fR
+1
-1
odoc/test/generators/man/Module_type_subst.Nested.3o
+1
-1
odoc/test/generators/man/Module_type_subst.Nested.3o
+1
-1
odoc/test/generators/man/Nested.3o
+1
-1
odoc/test/generators/man/Nested.3o
···
68
68
\fB3 Functor\fR
69
69
.in
70
70
.sp
71
-
\f[CB]module\fR F (Arg1 : Y) (Arg2 : \f[CB]sig\fR \.\.\. \f[CB]end\fR) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
71
+
\f[CB]module\fR F (Arg1 : Nested\.Y) (Arg2 : \f[CB]sig\fR \.\.\. \f[CB]end\fR) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
72
72
.fi
73
73
.br
74
74
.ti +2
+1
-1
odoc/test/generators/man/Nested.F.3o
+1
-1
odoc/test/generators/man/Nested.F.3o
+1
-1
odoc/test/generators/man/Nested.X.3o
+1
-1
odoc/test/generators/man/Nested.X.3o
+87
-81
odoc/test/generators/man/Ocamlary.3o
+87
-81
odoc/test/generators/man/Ocamlary.3o
···
177
177
\fB2 Section 9000\fR
178
178
.in
179
179
.sp
180
-
\f[CB]module\fR EmptyAlias = Empty
180
+
\f[CB]module\fR EmptyAlias = Ocamlary\.Empty
181
181
.fi
182
182
.br
183
183
.ti +2
···
195
195
A plain, empty module signature
196
196
.nf
197
197
.sp
198
-
\f[CB]module\fR \f[CB]type\fR EmptySigAlias = EmptySig
198
+
\f[CB]module\fR \f[CB]type\fR EmptySigAlias = Ocamlary\.EmptySig
199
199
.fi
200
200
.br
201
201
.ti +2
202
202
A plain, empty module signature alias of
203
203
.nf
204
204
.sp
205
-
\f[CB]module\fR ModuleWithSignature : EmptySig
205
+
\f[CB]module\fR ModuleWithSignature : Ocamlary\.EmptySig
206
206
.fi
207
207
.br
208
208
.ti +2
209
209
A plain module of a signature of \f[CI]EmptySig\fR (reference)
210
210
.nf
211
211
.sp
212
-
\f[CB]module\fR ModuleWithSignatureAlias : EmptySigAlias
212
+
\f[CB]module\fR ModuleWithSignatureAlias : Ocamlary\.EmptySigAlias
213
213
.fi
214
214
.br
215
215
.ti +2
···
380
380
@returns: the y coordinate
381
381
.nf
382
382
.sp
383
-
\f[CB]val\fR fun_fun_fun : ((int, int) a_function, (unit, unit) a_function) a_function
383
+
\f[CB]val\fR fun_fun_fun :
384
+
((int, int) Ocamlary\.a_function, (unit, unit) Ocamlary\.a_function)
385
+
Ocamlary\.a_function
384
386
.sp
385
387
\f[CB]val\fR fun_maybe : \f[CB]?yes\fR:unit \f[CB]\->\fR unit \f[CB]\->\fR int
386
388
.sp
···
520
522
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
521
523
.br
522
524
.ti +6
523
-
\f[CB]type\fR t = (unit, unit) a_function
525
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
524
526
.fi
525
527
.br
526
528
.ti +8
···
540
542
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
541
543
.br
542
544
.ti +6
543
-
\f[CB]type\fR t = InnerModuleA'\.t
545
+
\f[CB]type\fR t = InnerModuleA\.InnerModuleA'\.t
544
546
.fi
545
547
.br
546
548
.ti +8
···
582
584
.nf
583
585
.sp
584
586
\f[CB]module\fR Recollection
585
-
(C : COLLECTION) :
586
-
COLLECTION
587
+
(C : Ocamlary\.COLLECTION) :
588
+
Ocamlary\.COLLECTION
587
589
\f[CB]with\fR \f[CB]type\fR collection = C\.element list
588
590
\f[CB]and\fR \f[CB]type\fR element = C\.collection
589
591
.fi
···
612
614
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
613
615
.br
614
616
.ti +6
615
-
\f[CB]type\fR t = collection
617
+
\f[CB]type\fR t = C\.collection
616
618
.fi
617
619
.br
618
620
.ti +8
···
623
625
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
624
626
.br
625
627
.ti +8
626
-
\f[CB]type\fR t = (unit, unit) a_function
628
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
627
629
.fi
628
630
.br
629
631
.ti +10
···
643
645
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
644
646
.br
645
647
.ti +8
646
-
\f[CB]type\fR t = InnerModuleA'\.t
648
+
\f[CB]type\fR t = C\.InnerModuleA\.InnerModuleA'\.t
647
649
.fi
648
650
.br
649
651
.ti +10
···
669
671
.nf
670
672
.sp
671
673
.ti +4
672
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
674
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = C\.InnerModuleA\.InnerModuleTypeA'
673
675
.fi
674
676
.br
675
677
.ti +6
···
691
693
\f[CB]module\fR \f[CB]type\fR RECOLLECTION = \f[CB]sig\fR
692
694
.br
693
695
.ti +2
694
-
\f[CB]module\fR C = Recollection(CollectionModule)
696
+
\f[CB]module\fR C = Ocamlary\.Recollection(Ocamlary\.CollectionModule)
695
697
.br
696
698
\f[CB]end\fR
697
699
.sp
698
700
\f[CB]module\fR \f[CB]type\fR RecollectionModule = \f[CB]sig\fR
699
701
.br
700
702
.ti +2
701
-
\f[CB]type\fR collection = CollectionModule\.element list
703
+
\f[CB]type\fR collection = Ocamlary\.CollectionModule\.element list
702
704
.sp
703
705
.ti +2
704
-
\f[CB]type\fR element = CollectionModule\.collection
706
+
\f[CB]type\fR element = Ocamlary\.CollectionModule\.collection
705
707
.sp
706
708
.ti +2
707
709
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
···
718
720
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
719
721
.br
720
722
.ti +6
721
-
\f[CB]type\fR t = (unit, unit) a_function
723
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
722
724
.fi
723
725
.br
724
726
.ti +8
···
738
740
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
739
741
.br
740
742
.ti +6
741
-
\f[CB]type\fR t = InnerModuleA'\.t
743
+
\f[CB]type\fR t = InnerModuleA\.InnerModuleA'\.t
742
744
.fi
743
745
.br
744
746
.ti +8
···
797
799
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
798
800
.br
799
801
.ti +6
800
-
\f[CB]type\fR t = collection
802
+
\f[CB]type\fR t = Q\.collection
801
803
.fi
802
804
.br
803
805
.ti +8
···
808
810
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
809
811
.br
810
812
.ti +8
811
-
\f[CB]type\fR t = (unit, unit) a_function
813
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
812
814
.fi
813
815
.br
814
816
.ti +10
···
828
830
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
829
831
.br
830
832
.ti +8
831
-
\f[CB]type\fR t = InnerModuleA'\.t
833
+
\f[CB]type\fR t = Q\.InnerModuleA\.InnerModuleA'\.t
832
834
.fi
833
835
.br
834
836
.ti +10
···
854
856
.nf
855
857
.sp
856
858
.ti +4
857
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
859
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = Q\.InnerModuleA\.InnerModuleTypeA'
858
860
.fi
859
861
.br
860
862
.ti +6
···
896
898
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
897
899
.br
898
900
.ti +6
899
-
\f[CB]type\fR t = collection
901
+
\f[CB]type\fR t = Q\.collection
900
902
.fi
901
903
.br
902
904
.ti +8
···
907
909
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
908
910
.br
909
911
.ti +8
910
-
\f[CB]type\fR t = (unit, unit) a_function
912
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
911
913
.fi
912
914
.br
913
915
.ti +10
···
927
929
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
928
930
.br
929
931
.ti +8
930
-
\f[CB]type\fR t = InnerModuleA'\.t
932
+
\f[CB]type\fR t = Q\.InnerModuleA\.InnerModuleA'\.t
931
933
.fi
932
934
.br
933
935
.ti +10
···
953
955
.nf
954
956
.sp
955
957
.ti +4
956
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
958
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = Q\.InnerModuleA\.InnerModuleTypeA'
957
959
.fi
958
960
.br
959
961
.ti +6
···
995
997
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
996
998
.br
997
999
.ti +6
998
-
\f[CB]type\fR t = collection
1000
+
\f[CB]type\fR t = Q\.collection
999
1001
.fi
1000
1002
.br
1001
1003
.ti +8
···
1006
1008
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
1007
1009
.br
1008
1010
.ti +8
1009
-
\f[CB]type\fR t = (unit, unit) a_function
1011
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
1010
1012
.fi
1011
1013
.br
1012
1014
.ti +10
···
1026
1028
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
1027
1029
.br
1028
1030
.ti +8
1029
-
\f[CB]type\fR t = InnerModuleA'\.t
1031
+
\f[CB]type\fR t = Q\.InnerModuleA\.InnerModuleA'\.t
1030
1032
.fi
1031
1033
.br
1032
1034
.ti +10
···
1052
1054
.nf
1053
1055
.sp
1054
1056
.ti +4
1055
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
1057
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = Q\.InnerModuleA\.InnerModuleTypeA'
1056
1058
.fi
1057
1059
.br
1058
1060
.ti +6
···
1079
1081
.nf
1080
1082
.sp
1081
1083
\f[CB]module\fR FunctorTypeOf
1082
-
(Collection : \f[CB]module\fR \f[CB]type\fR \f[CB]of\fR CollectionModule) :
1084
+
(Collection : \f[CB]module\fR \f[CB]type\fR \f[CB]of\fR Ocamlary\.CollectionModule) :
1083
1085
\f[CB]sig\fR \.\.\. \f[CB]end\fR
1084
1086
.fi
1085
1087
.br
···
1243
1245
\f[CB]type\fR (_, _) full_gadt =
1244
1246
.br
1245
1247
.ti +2
1246
-
| \f[CB]Tag\fR : (unit, unit) full_gadt
1248
+
| \f[CB]Tag\fR : (unit, unit) Ocamlary\.full_gadt
1247
1249
.br
1248
1250
.ti +2
1249
-
| \f[CB]First\fR : \f[CB]'a\fR \f[CB]\->\fR (\f[CB]'a\fR, unit) full_gadt
1251
+
| \f[CB]First\fR : \f[CB]'a\fR \f[CB]\->\fR (\f[CB]'a\fR, unit) Ocamlary\.full_gadt
1250
1252
.br
1251
1253
.ti +2
1252
-
| \f[CB]Second\fR : \f[CB]'a\fR \f[CB]\->\fR (unit, \f[CB]'a\fR) full_gadt
1254
+
| \f[CB]Second\fR : \f[CB]'a\fR \f[CB]\->\fR (unit, \f[CB]'a\fR) Ocamlary\.full_gadt
1253
1255
.br
1254
1256
.ti +2
1255
-
| \f[CB]Exist\fR : \f[CB]'a\fR * \f[CB]'b\fR \f[CB]\->\fR (\f[CB]'b\fR, unit) full_gadt
1257
+
| \f[CB]Exist\fR : \f[CB]'a\fR * \f[CB]'b\fR \f[CB]\->\fR (\f[CB]'b\fR, unit) Ocamlary\.full_gadt
1256
1258
.br
1257
1259
.fi
1258
1260
.br
···
1266
1268
\f[CB]type\fR 'a partial_gadt =
1267
1269
.br
1268
1270
.ti +2
1269
-
| \f[CB]AscribeTag\fR : \f[CB]'a\fR partial_gadt
1271
+
| \f[CB]AscribeTag\fR : \f[CB]'a\fR Ocamlary\.partial_gadt
1270
1272
.br
1271
1273
.ti +2
1272
-
| \f[CB]OfTag\fR \f[CB]of\fR \f[CB]'a\fR partial_gadt
1274
+
| \f[CB]OfTag\fR \f[CB]of\fR \f[CB]'a\fR Ocamlary\.partial_gadt
1273
1275
.br
1274
1276
.ti +2
1275
-
| \f[CB]ExistGadtTag\fR : (\f[CB]'a\fR \f[CB]\->\fR \f[CB]'b\fR) \f[CB]\->\fR \f[CB]'a\fR partial_gadt
1277
+
| \f[CB]ExistGadtTag\fR : (\f[CB]'a\fR \f[CB]\->\fR \f[CB]'b\fR) \f[CB]\->\fR \f[CB]'a\fR Ocamlary\.partial_gadt
1276
1278
.br
1277
1279
.fi
1278
1280
.br
···
1283
1285
Wow! It was a mixed GADT!
1284
1286
.nf
1285
1287
.sp
1286
-
\f[CB]type\fR alias = variant
1288
+
\f[CB]type\fR alias = Ocamlary\.variant
1287
1289
.fi
1288
1290
.br
1289
1291
.ti +2
1290
1292
This comment is for alias\.
1291
1293
.nf
1292
1294
.sp
1293
-
\f[CB]type\fR tuple = (alias * alias) * alias * (alias * alias)
1295
+
\f[CB]type\fR tuple =
1296
+
(Ocamlary\.alias * Ocamlary\.alias)
1297
+
* Ocamlary\.alias
1298
+
* (Ocamlary\.alias * Ocamlary\.alias)
1294
1299
.fi
1295
1300
.br
1296
1301
.ti +2
1297
1302
This comment is for tuple\.
1298
1303
.nf
1299
1304
.sp
1300
-
\f[CB]type\fR variant_alias = variant =
1305
+
\f[CB]type\fR variant_alias = Ocamlary\.variant =
1301
1306
.br
1302
1307
.ti +2
1303
1308
| \f[CB]TagA\fR
···
1317
1322
This comment is for variant_alias\.
1318
1323
.nf
1319
1324
.sp
1320
-
\f[CB]type\fR record_alias = record = {
1325
+
\f[CB]type\fR record_alias = Ocamlary\.record = {
1321
1326
.br
1322
1327
.ti +2
1323
1328
field1 : int;
···
1335
1340
\f[CB]type\fR poly_variant_union = [
1336
1341
.br
1337
1342
.ti +2
1338
-
| poly_variant
1343
+
| Ocamlary\.poly_variant
1339
1344
.br
1340
1345
.ti +2
1341
1346
| `TagC
···
1368
1373
.sp
1369
1374
\f[CB]type\fR 'a open_poly_variant2 = [> `ConstrB of int ] \f[CB]as\fR 'a
1370
1375
.sp
1371
-
\f[CB]type\fR 'a open_poly_variant_alias = \f[CB]'a\fR open_poly_variant open_poly_variant2
1376
+
\f[CB]type\fR 'a open_poly_variant_alias =
1377
+
\f[CB]'a\fR Ocamlary\.open_poly_variant Ocamlary\.open_poly_variant2
1372
1378
.sp
1373
1379
\f[CB]type\fR 'a poly_fun = ([> `ConstrB of int ] \f[CB]as\fR 'a) \f[CB]\->\fR \f[CB]'a\fR
1374
1380
.sp
···
1394
1400
.br
1395
1401
]
1396
1402
.sp
1397
-
\f[CB]type\fR ('a, 'b) full_gadt_alias = (\f[CB]'a\fR, \f[CB]'b\fR) full_gadt =
1403
+
\f[CB]type\fR ('a, 'b) full_gadt_alias = (\f[CB]'a\fR, \f[CB]'b\fR) Ocamlary\.full_gadt =
1398
1404
.br
1399
1405
.ti +2
1400
-
| \f[CB]Tag\fR : (unit, unit) full_gadt_alias
1406
+
| \f[CB]Tag\fR : (unit, unit) Ocamlary\.full_gadt_alias
1401
1407
.br
1402
1408
.ti +2
1403
-
| \f[CB]First\fR : \f[CB]'a\fR \f[CB]\->\fR (\f[CB]'a\fR, unit) full_gadt_alias
1409
+
| \f[CB]First\fR : \f[CB]'a\fR \f[CB]\->\fR (\f[CB]'a\fR, unit) Ocamlary\.full_gadt_alias
1404
1410
.br
1405
1411
.ti +2
1406
-
| \f[CB]Second\fR : \f[CB]'a\fR \f[CB]\->\fR (unit, \f[CB]'a\fR) full_gadt_alias
1412
+
| \f[CB]Second\fR : \f[CB]'a\fR \f[CB]\->\fR (unit, \f[CB]'a\fR) Ocamlary\.full_gadt_alias
1407
1413
.br
1408
1414
.ti +2
1409
-
| \f[CB]Exist\fR : \f[CB]'a\fR * \f[CB]'b\fR \f[CB]\->\fR (\f[CB]'b\fR, unit) full_gadt_alias
1415
+
| \f[CB]Exist\fR : \f[CB]'a\fR * \f[CB]'b\fR \f[CB]\->\fR (\f[CB]'b\fR, unit) Ocamlary\.full_gadt_alias
1410
1416
.br
1411
1417
.fi
1412
1418
.br
···
1414
1420
This comment is for full_gadt_alias\.
1415
1421
.nf
1416
1422
.sp
1417
-
\f[CB]type\fR 'a partial_gadt_alias = \f[CB]'a\fR partial_gadt =
1423
+
\f[CB]type\fR 'a partial_gadt_alias = \f[CB]'a\fR Ocamlary\.partial_gadt =
1418
1424
.br
1419
1425
.ti +2
1420
-
| \f[CB]AscribeTag\fR : \f[CB]'a\fR partial_gadt_alias
1426
+
| \f[CB]AscribeTag\fR : \f[CB]'a\fR Ocamlary\.partial_gadt_alias
1421
1427
.br
1422
1428
.ti +2
1423
-
| \f[CB]OfTag\fR \f[CB]of\fR \f[CB]'a\fR partial_gadt_alias
1429
+
| \f[CB]OfTag\fR \f[CB]of\fR \f[CB]'a\fR Ocamlary\.partial_gadt_alias
1424
1430
.br
1425
1431
.ti +2
1426
-
| \f[CB]ExistGadtTag\fR : (\f[CB]'a\fR \f[CB]\->\fR \f[CB]'b\fR) \f[CB]\->\fR \f[CB]'a\fR partial_gadt_alias
1432
+
| \f[CB]ExistGadtTag\fR : (\f[CB]'a\fR \f[CB]\->\fR \f[CB]'b\fR) \f[CB]\->\fR \f[CB]'a\fR Ocamlary\.partial_gadt_alias
1427
1433
.br
1428
1434
.fi
1429
1435
.br
···
1444
1450
| \f[CB]A\fR
1445
1451
.br
1446
1452
.ti +2
1447
-
| \f[CB]B_ish\fR \f[CB]of\fR mutual_constr_b
1453
+
| \f[CB]B_ish\fR \f[CB]of\fR Ocamlary\.mutual_constr_b
1448
1454
.br
1449
1455
.ti +4
1450
1456
(* This comment is between \f[CI]mutual_constr_a\fR and \f[CI]mutual_constr_b\fR\. *)
···
1461
1467
| \f[CB]B\fR
1462
1468
.br
1463
1469
.ti +2
1464
-
| \f[CB]A_ish\fR \f[CB]of\fR mutual_constr_a
1470
+
| \f[CB]A_ish\fR \f[CB]of\fR Ocamlary\.mutual_constr_a
1465
1471
.br
1466
1472
.ti +4
1467
1473
(* This comment must be here for the next to associate correctly\. *)
···
1472
1478
This comment is for \f[CI]mutual_constr_b\fR then \f[CI]mutual_constr_a\fR\.
1473
1479
.nf
1474
1480
.sp
1475
-
\f[CB]type\fR rec_obj = < f : int ; g : unit \f[CB]\->\fR unit ; h : rec_obj >
1481
+
\f[CB]type\fR rec_obj = < f : int ; g : unit \f[CB]\->\fR unit ; h : Ocamlary\.rec_obj >
1476
1482
.sp
1477
1483
\f[CB]type\fR 'a open_obj = < f : int ; g : unit \f[CB]\->\fR unit\.\. > \f[CB]as\fR 'a
1478
1484
.sp
···
1491
1497
A mystery wrapped in an ellipsis
1492
1498
.nf
1493
1499
.sp
1494
-
\f[CB]type\fR ext +=
1500
+
\f[CB]type\fR Ocamlary\.ext +=
1495
1501
.br
1496
1502
.ti +2
1497
1503
| \f[CB]ExtA\fR
1498
1504
.br
1499
1505
.sp
1500
-
\f[CB]type\fR ext +=
1506
+
\f[CB]type\fR Ocamlary\.ext +=
1501
1507
.br
1502
1508
.ti +2
1503
1509
| \f[CB]ExtB\fR
1504
1510
.br
1505
1511
.sp
1506
-
\f[CB]type\fR ext +=
1512
+
\f[CB]type\fR Ocamlary\.ext +=
1507
1513
.br
1508
1514
.ti +2
1509
1515
| \f[CB]ExtC\fR \f[CB]of\fR unit
1510
1516
.br
1511
1517
.ti +2
1512
-
| \f[CB]ExtD\fR \f[CB]of\fR ext
1518
+
| \f[CB]ExtD\fR \f[CB]of\fR Ocamlary\.ext
1513
1519
.br
1514
1520
.sp
1515
-
\f[CB]type\fR ext +=
1521
+
\f[CB]type\fR Ocamlary\.ext +=
1516
1522
.br
1517
1523
.ti +2
1518
1524
| \f[CB]ExtE\fR
1519
1525
.br
1520
1526
.sp
1521
-
\f[CB]type\fR ext += \f[CB]private\fR
1527
+
\f[CB]type\fR Ocamlary\.ext += \f[CB]private\fR
1522
1528
.br
1523
1529
.ti +2
1524
1530
| \f[CB]ExtF\fR
···
1531
1537
'a poly_ext
1532
1538
.nf
1533
1539
.sp
1534
-
\f[CB]type\fR poly_ext +=
1540
+
\f[CB]type\fR Ocamlary\.poly_ext +=
1535
1541
.br
1536
1542
.ti +2
1537
1543
| \f[CB]Foo\fR \f[CB]of\fR \f[CB]'b\fR
···
1543
1549
(* 'b poly_ext *)
1544
1550
.br
1545
1551
.sp
1546
-
\f[CB]type\fR poly_ext +=
1552
+
\f[CB]type\fR Ocamlary\.poly_ext +=
1547
1553
.br
1548
1554
.ti +2
1549
1555
| \f[CB]Quux\fR \f[CB]of\fR \f[CB]'c\fR
···
1554
1560
.sp
1555
1561
\f[CB]module\fR ExtMod : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1556
1562
.sp
1557
-
\f[CB]type\fR ExtMod\.t +=
1563
+
\f[CB]type\fR Ocamlary\.ExtMod\.t +=
1558
1564
.br
1559
1565
.ti +2
1560
1566
| \f[CB]ZzzTop0\fR
···
1563
1569
(* It's got the rock *)
1564
1570
.br
1565
1571
.sp
1566
-
\f[CB]type\fR ExtMod\.t +=
1572
+
\f[CB]type\fR Ocamlary\.ExtMod\.t +=
1567
1573
.br
1568
1574
.ti +2
1569
1575
| \f[CB]ZzzTop\fR \f[CB]of\fR unit
···
1579
1585
Rotate keys on my mark\.\.\.
1580
1586
.nf
1581
1587
.sp
1582
-
\f[CB]type\fR my_mod = (\f[CB]module\fR COLLECTION)
1588
+
\f[CB]type\fR my_mod = (\f[CB]module\fR Ocamlary\.COLLECTION)
1583
1589
.fi
1584
1590
.br
1585
1591
.ti +2
···
1610
1616
.sp
1611
1617
\f[CB]module\fR Dep5 (Arg : \f[CB]sig\fR \.\.\. \f[CB]end\fR) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1612
1618
.sp
1613
-
\f[CB]type\fR dep2 = Dep5(Dep4)\.Z\.X\.b
1619
+
\f[CB]type\fR dep2 = Ocamlary\.Dep5(Ocamlary\.Dep4)\.Z\.X\.b
1614
1620
.sp
1615
1621
\f[CB]type\fR dep3 = Dep5(Dep4)\.Z\.Y\.a
1616
1622
.sp
···
1618
1624
.sp
1619
1625
\f[CB]module\fR Dep7 (Arg : \f[CB]sig\fR \.\.\. \f[CB]end\fR) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1620
1626
.sp
1621
-
\f[CB]type\fR dep4 = Dep7(Dep6)\.M\.Y\.d
1627
+
\f[CB]type\fR dep4 = Ocamlary\.Dep7(Ocamlary\.Dep6)\.M\.Y\.d
1622
1628
.sp
1623
1629
\f[CB]module\fR Dep8 : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1624
1630
.sp
···
1635
1641
.sp
1636
1642
\f[CB]module\fR Dep12 (Arg : \f[CB]sig\fR \.\.\. \f[CB]end\fR) : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1637
1643
.sp
1638
-
\f[CB]module\fR Dep13 : Dep12(Dep11)\.T
1644
+
\f[CB]module\fR Dep13 : Ocamlary\.Dep12(Ocamlary\.Dep11)\.T
1639
1645
.sp
1640
-
\f[CB]type\fR dep5 = Dep13\.c
1646
+
\f[CB]type\fR dep5 = Ocamlary\.Dep13\.c
1641
1647
.sp
1642
1648
\f[CB]module\fR \f[CB]type\fR With1 = \f[CB]sig\fR
1643
1649
.br
···
1657
1663
.sp
1658
1664
\f[CB]module\fR With2 : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1659
1665
.sp
1660
-
\f[CB]module\fR With3 : With1 \f[CB]with\fR \f[CB]module\fR M = With2
1666
+
\f[CB]module\fR With3 : Ocamlary\.With1 \f[CB]with\fR \f[CB]module\fR M = Ocamlary\.With2
1661
1667
.sp
1662
-
\f[CB]type\fR with1 = With3\.N\.t
1668
+
\f[CB]type\fR with1 = Ocamlary\.With3\.N\.t
1663
1669
.sp
1664
-
\f[CB]module\fR With4 : With1 \f[CB]with\fR \f[CB]module\fR M := With2
1670
+
\f[CB]module\fR With4 : Ocamlary\.With1 \f[CB]with\fR \f[CB]module\fR M := Ocamlary\.With2
1665
1671
.sp
1666
-
\f[CB]type\fR with2 = With4\.N\.t
1672
+
\f[CB]type\fR with2 = Ocamlary\.With4\.N\.t
1667
1673
.sp
1668
1674
\f[CB]module\fR With5 : \f[CB]sig\fR \.\.\. \f[CB]end\fR
1669
1675
.sp
···
1677
1683
\f[CB]module\fR M : \f[CB]sig\fR
1678
1684
.br
1679
1685
.ti +4
1680
-
\f[CB]module\fR \f[CB]type\fR S = With5\.S
1686
+
\f[CB]module\fR \f[CB]type\fR S = Ocamlary\.With5\.S
1681
1687
.sp
1682
1688
.ti +4
1683
1689
\f[CB]module\fR N : \f[CB]sig\fR
1684
1690
.br
1685
1691
.ti +6
1686
-
\f[CB]type\fR t = With5\.N\.t
1692
+
\f[CB]type\fR t = Ocamlary\.With5\.N\.t
1687
1693
.br
1688
1694
.ti +4
1689
1695
\f[CB]end\fR
···
1700
1706
\f[CB]module\fR \f[CB]type\fR With11 = \f[CB]sig\fR
1701
1707
.br
1702
1708
.ti +2
1703
-
\f[CB]module\fR M = With9
1709
+
\f[CB]module\fR M = Ocamlary\.With9
1704
1710
.sp
1705
1711
.ti +2
1706
1712
\f[CB]module\fR N : \f[CB]sig\fR
···
1882
1888
.sp
1883
1889
\f[CB]type\fR new_t = \.\.
1884
1890
.sp
1885
-
\f[CB]type\fR new_t +=
1891
+
\f[CB]type\fR Ocamlary\.new_t +=
1886
1892
.br
1887
1893
.ti +2
1888
1894
| \f[CB]C\fR
···
1891
1897
\f[CB]module\fR \f[CB]type\fR TypeExtPruned = \f[CB]sig\fR
1892
1898
.br
1893
1899
.ti +2
1894
-
\f[CB]type\fR new_t +=
1900
+
\f[CB]type\fR Ocamlary\.new_t +=
1895
1901
.br
1896
1902
.ti +4
1897
1903
| \f[CB]C\fR
···
1899
1905
.ti +2
1900
1906
.sp
1901
1907
.ti +2
1902
-
\f[CB]val\fR f : new_t \f[CB]\->\fR unit
1908
+
\f[CB]val\fR f : Ocamlary\.new_t \f[CB]\->\fR unit
1903
1909
.br
1904
1910
\f[CB]end\fR
1905
1911
.sp
+7
-7
odoc/test/generators/man/Ocamlary.Aliases.3o
+7
-7
odoc/test/generators/man/Ocamlary.Aliases.3o
···
20
20
.sp
21
21
\f[CB]type\fR tata = Foo\.A\.t
22
22
.sp
23
-
\f[CB]type\fR tbtb = Foo\.B\.t
23
+
\f[CB]type\fR tbtb = Ocamlary\.Aliases\.Foo\.B\.t
24
24
.sp
25
25
\f[CB]type\fR tete
26
26
.sp
27
27
\f[CB]type\fR tata' = A'\.t
28
28
.sp
29
-
\f[CB]type\fR tete2 = Foo\.E\.t
29
+
\f[CB]type\fR tete2 = Ocamlary\.Aliases\.Foo\.E\.t
30
30
.sp
31
31
\f[CB]module\fR Std : \f[CB]sig\fR \.\.\. \f[CB]end\fR
32
32
.sp
···
40
40
Just for giggle, let's see what happens when we include \f[CI]Foo\fR\.
41
41
.nf
42
42
.sp
43
-
\f[CB]module\fR A = Foo\.A
43
+
\f[CB]module\fR A = Ocamlary\.Aliases\.Foo\.A
44
44
.sp
45
-
\f[CB]module\fR B = Foo\.B
45
+
\f[CB]module\fR B = Ocamlary\.Aliases\.Foo\.B
46
46
.sp
47
-
\f[CB]module\fR C = Foo\.C
47
+
\f[CB]module\fR C = Ocamlary\.Aliases\.Foo\.C
48
48
.sp
49
-
\f[CB]module\fR D = Foo\.D
49
+
\f[CB]module\fR D = Ocamlary\.Aliases\.Foo\.D
50
50
.sp
51
51
\f[CB]module\fR E : \f[CB]sig\fR \.\.\. \f[CB]end\fR
52
52
.sp
···
60
60
.sp
61
61
\f[CB]module\fR P2 : \f[CB]sig\fR \.\.\. \f[CB]end\fR
62
62
.sp
63
-
\f[CB]module\fR X1 = P2\.Z
63
+
\f[CB]module\fR X1 = Ocamlary\.Aliases\.P2\.Z
64
64
.sp
65
65
\f[CB]module\fR X2 = P2\.Z
66
66
.sp
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.E.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.E.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.A.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.A.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.B.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.B.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.C.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.C.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.D.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.D.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.E.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Foo.E.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.P1.Y.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.P1.Y.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.P2.Z.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.P2.Z.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Std.3o
+1
-1
odoc/test/generators/man/Ocamlary.Aliases.Std.3o
+3
-1
odoc/test/generators/man/Ocamlary.CanonicalTest.3o
+3
-1
odoc/test/generators/man/Ocamlary.CanonicalTest.3o
···
15
15
.sp
16
16
\f[CB]module\fR Base_Tests : \f[CB]sig\fR \.\.\. \f[CB]end\fR
17
17
.sp
18
-
\f[CB]module\fR List_modif : \f[CB]module\fR \f[CB]type\fR \f[CB]of\fR Base\.List \f[CB]with\fR \f[CB]type\fR 'c t = \f[CB]'c\fR Base\.List\.t
18
+
\f[CB]module\fR List_modif :
19
+
\f[CB]module\fR \f[CB]type\fR \f[CB]of\fR Base\.List
20
+
\f[CB]with\fR \f[CB]type\fR 'c t = \f[CB]'c\fR Ocamlary\.CanonicalTest\.Base\.List\.t
+3
-1
odoc/test/generators/man/Ocamlary.CanonicalTest.Base.List.3o
+3
-1
odoc/test/generators/man/Ocamlary.CanonicalTest.Base.List.3o
+6
-4
odoc/test/generators/man/Ocamlary.CanonicalTest.Base_Tests.3o
+6
-4
odoc/test/generators/man/Ocamlary.CanonicalTest.Base_Tests.3o
···
11
11
.SH Documentation
12
12
.sp
13
13
.nf
14
-
\f[CB]module\fR C : \f[CB]module\fR \f[CB]type\fR \f[CB]of\fR Base\.List
14
+
\f[CB]module\fR C : \f[CB]module\fR \f[CB]type\fR \f[CB]of\fR Ocamlary\.CanonicalTest\.Base\.List
15
15
.sp
16
-
\f[CB]module\fR L = Base\.List
16
+
\f[CB]module\fR L = Ocamlary\.CanonicalTest\.Base\.List
17
17
.sp
18
18
\f[CB]val\fR foo : int L\.t \f[CB]\->\fR float L\.t
19
19
.sp
20
-
\f[CB]val\fR bar : \f[CB]'a\fR Base\.List\.t \f[CB]\->\fR \f[CB]'a\fR Base\.List\.t
20
+
\f[CB]val\fR bar :
21
+
\f[CB]'a\fR Ocamlary\.CanonicalTest\.Base\.List\.t \f[CB]\->\fR
22
+
\f[CB]'a\fR Ocamlary\.CanonicalTest\.Base\.List\.t
21
23
.sp
22
-
\f[CB]val\fR baz : \f[CB]'a\fR Base\.List\.t \f[CB]\->\fR unit
24
+
\f[CB]val\fR baz : \f[CB]'a\fR Ocamlary\.CanonicalTest\.Base\.List\.t \f[CB]\->\fR unit
+3
-1
odoc/test/generators/man/Ocamlary.CanonicalTest.Base_Tests.C.3o
+3
-1
odoc/test/generators/man/Ocamlary.CanonicalTest.Base_Tests.C.3o
+4
-2
odoc/test/generators/man/Ocamlary.CanonicalTest.List_modif.3o
+4
-2
odoc/test/generators/man/Ocamlary.CanonicalTest.List_modif.3o
···
11
11
.SH Documentation
12
12
.sp
13
13
.nf
14
-
\f[CB]type\fR 'c t = \f[CB]'c\fR Base\.List\.t
14
+
\f[CB]type\fR 'c t = \f[CB]'c\fR Ocamlary\.CanonicalTest\.Base\.List\.t
15
15
.sp
16
-
\f[CB]val\fR id : \f[CB]'a\fR t \f[CB]\->\fR \f[CB]'a\fR t
16
+
\f[CB]val\fR id :
17
+
\f[CB]'a\fR Ocamlary\.CanonicalTest\.List_modif\.t \f[CB]\->\fR
18
+
\f[CB]'a\fR Ocamlary\.CanonicalTest\.List_modif\.t
+2
-1
odoc/test/generators/man/Ocamlary.CollectionModule.3o
+2
-1
odoc/test/generators/man/Ocamlary.CollectionModule.3o
···
30
30
This comment is for InnerModuleA\.
31
31
.nf
32
32
.sp
33
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
33
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA =
34
+
Ocamlary\.CollectionModule\.InnerModuleA\.InnerModuleTypeA'
34
35
.fi
35
36
.br
36
37
.ti +2
+2
-2
odoc/test/generators/man/Ocamlary.CollectionModule.InnerModuleA.3o
+2
-2
odoc/test/generators/man/Ocamlary.CollectionModule.InnerModuleA.3o
···
14
14
.SH Documentation
15
15
.sp
16
16
.nf
17
-
\f[CB]type\fR t = collection
17
+
\f[CB]type\fR t = Ocamlary\.CollectionModule\.collection
18
18
.fi
19
19
.br
20
20
.ti +2
···
31
31
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
32
32
.br
33
33
.ti +2
34
-
\f[CB]type\fR t = InnerModuleA'\.t
34
+
\f[CB]type\fR t = Ocamlary\.CollectionModule\.InnerModuleA\.InnerModuleA'\.t
35
35
.fi
36
36
.br
37
37
.ti +4
+1
-1
odoc/test/generators/man/Ocamlary.CollectionModule.InnerModuleA.InnerModuleA'.3o
+1
-1
odoc/test/generators/man/Ocamlary.CollectionModule.InnerModuleA.InnerModuleA'.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep1.X.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep1.X.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep2.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep2.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep4.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep4.3o
+3
-3
odoc/test/generators/man/Ocamlary.Dep5.3o
+3
-3
odoc/test/generators/man/Ocamlary.Dep5.3o
···
25
25
\f[CB]module\fR \f[CB]type\fR S = \f[CB]sig\fR
26
26
.br
27
27
.ti +4
28
-
\f[CB]module\fR X : T
28
+
\f[CB]module\fR X : Arg\.T
29
29
.sp
30
30
.ti +4
31
31
\f[CB]module\fR Y : \f[CB]sig\fR \f[CB]end\fR
···
34
34
\f[CB]end\fR
35
35
.sp
36
36
.ti +2
37
-
\f[CB]module\fR X : T
37
+
\f[CB]module\fR X : Arg\.T
38
38
.br
39
39
\f[CB]end\fR
40
40
.sp
···
42
42
\fB2 Signature\fR
43
43
.in
44
44
.sp
45
-
\f[CB]module\fR Z : Arg\.S \f[CB]with\fR \f[CB]module\fR Y = Dep3
45
+
\f[CB]module\fR Z : Arg\.S \f[CB]with\fR \f[CB]module\fR Y = Ocamlary\.Dep3
+1
-1
odoc/test/generators/man/Ocamlary.Dep5.Z.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep5.Z.3o
+2
-2
odoc/test/generators/man/Ocamlary.Dep6.3o
+2
-2
odoc/test/generators/man/Ocamlary.Dep6.3o
···
21
21
\f[CB]module\fR \f[CB]type\fR T = \f[CB]sig\fR
22
22
.br
23
23
.ti +2
24
-
\f[CB]module\fR \f[CB]type\fR R = S
24
+
\f[CB]module\fR \f[CB]type\fR R = Ocamlary\.Dep6\.S
25
25
.sp
26
26
.ti +2
27
27
\f[CB]module\fR Y : \f[CB]sig\fR
···
34
34
.br
35
35
\f[CB]end\fR
36
36
.sp
37
-
\f[CB]module\fR X : T
37
+
\f[CB]module\fR X : Ocamlary\.Dep6\.T
+2
-2
odoc/test/generators/man/Ocamlary.Dep6.X.3o
+2
-2
odoc/test/generators/man/Ocamlary.Dep6.X.3o
+3
-3
odoc/test/generators/man/Ocamlary.Dep7.3o
+3
-3
odoc/test/generators/man/Ocamlary.Dep7.3o
···
25
25
\f[CB]module\fR \f[CB]type\fR T = \f[CB]sig\fR
26
26
.br
27
27
.ti +4
28
-
\f[CB]module\fR \f[CB]type\fR R = S
28
+
\f[CB]module\fR \f[CB]type\fR R = Arg\.S
29
29
.sp
30
30
.ti +4
31
31
\f[CB]module\fR Y : R
···
37
37
\f[CB]module\fR X : \f[CB]sig\fR
38
38
.br
39
39
.ti +4
40
-
\f[CB]module\fR \f[CB]type\fR R = S
40
+
\f[CB]module\fR \f[CB]type\fR R = Arg\.S
41
41
.sp
42
42
.ti +4
43
-
\f[CB]module\fR Y : R
43
+
\f[CB]module\fR Y : Arg\.X\.R
44
44
.br
45
45
.ti +2
46
46
\f[CB]end\fR
+1
-1
odoc/test/generators/man/Ocamlary.Dep7.M.3o
+1
-1
odoc/test/generators/man/Ocamlary.Dep7.M.3o
+1
-1
odoc/test/generators/man/Ocamlary.ExtMod.3o
+1
-1
odoc/test/generators/man/Ocamlary.ExtMod.3o
+4
-4
odoc/test/generators/man/Ocamlary.FunctorTypeOf.3o
+4
-4
odoc/test/generators/man/Ocamlary.FunctorTypeOf.3o
···
36
36
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
37
37
.br
38
38
.ti +4
39
-
\f[CB]type\fR t = collection
39
+
\f[CB]type\fR t = Collection\.collection
40
40
.fi
41
41
.br
42
42
.ti +6
···
47
47
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
48
48
.br
49
49
.ti +6
50
-
\f[CB]type\fR t = (unit, unit) a_function
50
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
51
51
.fi
52
52
.br
53
53
.ti +8
···
67
67
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
68
68
.br
69
69
.ti +6
70
-
\f[CB]type\fR t = InnerModuleA'\.t
70
+
\f[CB]type\fR t = Collection\.InnerModuleA\.InnerModuleA'\.t
71
71
.fi
72
72
.br
73
73
.ti +8
···
93
93
.nf
94
94
.sp
95
95
.ti +2
96
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
96
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = Collection\.InnerModuleA\.InnerModuleTypeA'
97
97
.fi
98
98
.br
99
99
.ti +4
+4
-4
odoc/test/generators/man/Ocamlary.Recollection.3o
+4
-4
odoc/test/generators/man/Ocamlary.Recollection.3o
···
36
36
\f[CB]module\fR InnerModuleA : \f[CB]sig\fR
37
37
.br
38
38
.ti +4
39
-
\f[CB]type\fR t = collection
39
+
\f[CB]type\fR t = C\.collection
40
40
.fi
41
41
.br
42
42
.ti +6
···
47
47
\f[CB]module\fR InnerModuleA' : \f[CB]sig\fR
48
48
.br
49
49
.ti +6
50
-
\f[CB]type\fR t = (unit, unit) a_function
50
+
\f[CB]type\fR t = (unit, unit) Ocamlary\.a_function
51
51
.fi
52
52
.br
53
53
.ti +8
···
67
67
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA' = \f[CB]sig\fR
68
68
.br
69
69
.ti +6
70
-
\f[CB]type\fR t = InnerModuleA'\.t
70
+
\f[CB]type\fR t = C\.InnerModuleA\.InnerModuleA'\.t
71
71
.fi
72
72
.br
73
73
.ti +8
···
93
93
.nf
94
94
.sp
95
95
.ti +2
96
-
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = InnerModuleA\.InnerModuleTypeA'
96
+
\f[CB]module\fR \f[CB]type\fR InnerModuleTypeA = C\.InnerModuleA\.InnerModuleTypeA'
97
97
.fi
98
98
.br
99
99
.ti +4
+1
-1
odoc/test/generators/man/Ocamlary.Recollection.InnerModuleA.3o
+1
-1
odoc/test/generators/man/Ocamlary.Recollection.InnerModuleA.3o
+1
-1
odoc/test/generators/man/Ocamlary.Recollection.InnerModuleA.InnerModuleA'.3o
+1
-1
odoc/test/generators/man/Ocamlary.Recollection.InnerModuleA.InnerModuleA'.3o
+1
-1
odoc/test/generators/man/Ocamlary.With3.3o
+1
-1
odoc/test/generators/man/Ocamlary.With3.3o
+1
-1
odoc/test/generators/man/Ocamlary.With4.3o
+1
-1
odoc/test/generators/man/Ocamlary.With4.3o
+1
-1
odoc/test/generators/man/Ocamlary.With5.3o
+1
-1
odoc/test/generators/man/Ocamlary.With5.3o
+1
-1
odoc/test/generators/man/Ocamlary.With6.3o
+1
-1
odoc/test/generators/man/Ocamlary.With6.3o
+5
-5
odoc/test/generators/man/Recent.3o
+5
-5
odoc/test/generators/man/Recent.3o
···
64
64
\f[CB]type\fR _ gadt =
65
65
.br
66
66
.ti +2
67
-
| \f[CB]A\fR : int gadt
67
+
| \f[CB]A\fR : int Recent\.gadt
68
68
.br
69
69
.ti +2
70
-
| \f[CB]B\fR : int \f[CB]\->\fR string gadt
70
+
| \f[CB]B\fR : int \f[CB]\->\fR string Recent\.gadt
71
71
.br
72
72
.ti +4
73
73
(* foo *)
···
79
79
a : int;
80
80
.br
81
81
.ti +4
82
-
} \f[CB]\->\fR unit gadt
82
+
} \f[CB]\->\fR unit Recent\.gadt
83
83
.br
84
84
.sp
85
85
\f[CB]type\fR polymorphic_variant = [
···
111
111
\f[CB]type\fR empty_conj =
112
112
.br
113
113
.ti +2
114
-
| \f[CB]X\fR : [< `X of & \f[CB]'a\fR & int * float ] \f[CB]\->\fR empty_conj
114
+
| \f[CB]X\fR : [< `X of & \f[CB]'a\fR & int * float ] \f[CB]\->\fR Recent\.empty_conj
115
115
.br
116
116
.sp
117
117
\f[CB]type\fR conj =
118
118
.br
119
119
.ti +2
120
-
| \f[CB]X\fR : [< `X of int & [< `B of int & float ] ] \f[CB]\->\fR conj
120
+
| \f[CB]X\fR : [< `X of int & [< `B of int & float ] ] \f[CB]\->\fR Recent\.conj
121
121
.br
122
122
.sp
123
123
\f[CB]val\fR empty_conj : [< `X of & \f[CB]'a\fR & int * float ]
+2
-2
odoc/test/generators/man/Recent.X.3o
+2
-2
odoc/test/generators/man/Recent.X.3o
+1
-1
odoc/test/generators/man/Recent_impl.3o
+1
-1
odoc/test/generators/man/Recent_impl.3o
+8
-8
odoc/test/generators/man/Stop_dead_link_doc.3o
+8
-8
odoc/test/generators/man/Stop_dead_link_doc.3o
···
16
16
\f[CB]type\fR foo =
17
17
.br
18
18
.ti +2
19
-
| \f[CB]Bar\fR \f[CB]of\fR Foo\.t
19
+
| \f[CB]Bar\fR \f[CB]of\fR Stop_dead_link_doc\.Foo\.t
20
20
.br
21
21
.sp
22
22
\f[CB]type\fR bar =
···
25
25
| \f[CB]Bar\fR \f[CB]of\fR {
26
26
.br
27
27
.ti +6
28
-
field : Foo\.t;
28
+
field : Stop_dead_link_doc\.Foo\.t;
29
29
.br
30
30
.ti +4
31
31
}
···
34
34
\f[CB]type\fR foo_ =
35
35
.br
36
36
.ti +2
37
-
| \f[CB]Bar_\fR \f[CB]of\fR int * Foo\.t * int
37
+
| \f[CB]Bar_\fR \f[CB]of\fR int * Stop_dead_link_doc\.Foo\.t * int
38
38
.br
39
39
.sp
40
40
\f[CB]type\fR bar_ =
41
41
.br
42
42
.ti +2
43
-
| \f[CB]Bar__\fR \f[CB]of\fR Foo\.t option
43
+
| \f[CB]Bar__\fR \f[CB]of\fR Stop_dead_link_doc\.Foo\.t option
44
44
.br
45
45
.sp
46
46
\f[CB]type\fR another_foo =
47
47
.br
48
48
.ti +2
49
-
| \f[CB]Bar\fR \f[CB]of\fR Another_Foo\.t
49
+
| \f[CB]Bar\fR \f[CB]of\fR Stop_dead_link_doc\.Another_Foo\.t
50
50
.br
51
51
.sp
52
52
\f[CB]type\fR another_bar =
···
55
55
| \f[CB]Bar\fR \f[CB]of\fR {
56
56
.br
57
57
.ti +6
58
-
field : Another_Foo\.t;
58
+
field : Stop_dead_link_doc\.Another_Foo\.t;
59
59
.br
60
60
.ti +4
61
61
}
···
64
64
\f[CB]type\fR another_foo_ =
65
65
.br
66
66
.ti +2
67
-
| \f[CB]Bar_\fR \f[CB]of\fR int * Another_Foo\.t * int
67
+
| \f[CB]Bar_\fR \f[CB]of\fR int * Stop_dead_link_doc\.Another_Foo\.t * int
68
68
.br
69
69
.sp
70
70
\f[CB]type\fR another_bar_ =
71
71
.br
72
72
.ti +2
73
-
| \f[CB]Bar__\fR \f[CB]of\fR Another_Foo\.t option
73
+
| \f[CB]Bar__\fR \f[CB]of\fR Stop_dead_link_doc\.Another_Foo\.t option
74
74
.br
75
75
+1
-1
odoc/test/generators/man/Toplevel_comments.3o
+1
-1
odoc/test/generators/man/Toplevel_comments.3o
+23
-23
odoc/test/generators/man/Type.3o
+23
-23
odoc/test/generators/man/Type.3o
···
42
42
.sp
43
43
\f[CB]type\fR nested_pair = (int * int) * int
44
44
.sp
45
-
\f[CB]type\fR instance = int constructor
45
+
\f[CB]type\fR instance = int Type\.constructor
46
46
.sp
47
47
\f[CB]type\fR long =
48
-
labeled_higher_order \f[CB]\->\fR
49
-
[ `Bar | `Baz of triple ] \f[CB]\->\fR
50
-
pair \f[CB]\->\fR
51
-
labeled \f[CB]\->\fR
52
-
higher_order \f[CB]\->\fR
48
+
Type\.labeled_higher_order \f[CB]\->\fR
49
+
[ `Bar | `Baz of Type\.triple ] \f[CB]\->\fR
50
+
Type\.pair \f[CB]\->\fR
51
+
Type\.labeled \f[CB]\->\fR
52
+
Type\.higher_order \f[CB]\->\fR
53
53
(string \f[CB]\->\fR int) \f[CB]\->\fR
54
54
(int * float * char * string * char * unit) option \f[CB]\->\fR
55
-
nested_pair \f[CB]\->\fR
56
-
arrow \f[CB]\->\fR
55
+
Type\.nested_pair \f[CB]\->\fR
56
+
Type\.arrow \f[CB]\->\fR
57
57
string \f[CB]\->\fR
58
-
nested_pair array
58
+
Type\.nested_pair array
59
59
.sp
60
60
\f[CB]type\fR variant_e = {
61
61
.br
···
85
85
(* bar *)
86
86
.br
87
87
.ti +2
88
-
| \f[CB]E\fR \f[CB]of\fR variant_e
88
+
| \f[CB]E\fR \f[CB]of\fR Type\.variant_e
89
89
.br
90
90
.sp
91
91
\f[CB]type\fR variant_c = {
···
98
98
\f[CB]type\fR _ gadt =
99
99
.br
100
100
.ti +2
101
-
| \f[CB]A\fR : int gadt
101
+
| \f[CB]A\fR : int Type\.gadt
102
102
.br
103
103
.ti +2
104
-
| \f[CB]B\fR : int \f[CB]\->\fR string gadt
104
+
| \f[CB]B\fR : int \f[CB]\->\fR string Type\.gadt
105
105
.br
106
106
.ti +2
107
-
| \f[CB]C\fR : variant_c \f[CB]\->\fR unit gadt
107
+
| \f[CB]C\fR : Type\.variant_c \f[CB]\->\fR unit Type\.gadt
108
108
.br
109
109
.sp
110
110
\f[CB]type\fR degenerate_gadt =
111
111
.br
112
112
.ti +2
113
-
| \f[CB]A\fR : degenerate_gadt
113
+
| \f[CB]A\fR : Type\.degenerate_gadt
114
114
.br
115
115
.sp
116
116
\f[CB]type\fR private_variant = \f[CB]private\fR
···
163
163
\f[CB]type\fR polymorphic_variant_extension = [
164
164
.br
165
165
.ti +2
166
-
| polymorphic_variant
166
+
| Type\.polymorphic_variant
167
167
.br
168
168
.ti +2
169
169
| `E
···
180
180
\f[CB]type\fR private_extenion = \f[CB]private\fR [>
181
181
.br
182
182
.ti +2
183
-
| polymorphic_variant
183
+
| Type\.polymorphic_variant
184
184
.br
185
185
]
186
186
.sp
···
196
196
.br
197
197
\f[CB]end\fR
198
198
.sp
199
-
\f[CB]type\fR module_ = (\f[CB]module\fR X)
199
+
\f[CB]type\fR module_ = (\f[CB]module\fR Type\.X)
200
200
.sp
201
-
\f[CB]type\fR module_substitution = (\f[CB]module\fR X \f[CB]with\fR \f[CB]type\fR t = int \f[CB]and\fR \f[CB]type\fR u = unit)
201
+
\f[CB]type\fR module_substitution = (\f[CB]module\fR Type\.X \f[CB]with\fR \f[CB]type\fR t = int \f[CB]and\fR \f[CB]type\fR u = unit)
202
202
.sp
203
203
\f[CB]type\fR +'a covariant
204
204
.sp
···
208
208
.sp
209
209
\f[CB]type\fR ('a, 'b) binary
210
210
.sp
211
-
\f[CB]type\fR using_binary = (int, int) binary
211
+
\f[CB]type\fR using_binary = (int, int) Type\.binary
212
212
.sp
213
213
\f[CB]type\fR 'custom name
214
214
.sp
···
222
222
.sp
223
223
\f[CB]type\fR 'a upper_variant = \f[CB]'a\fR \f[CB]constraint\fR \f[CB]'a\fR = [< `A | `B of int ]
224
224
.sp
225
-
\f[CB]type\fR 'a named_variant = \f[CB]'a\fR \f[CB]constraint\fR \f[CB]'a\fR = [< polymorphic_variant ]
225
+
\f[CB]type\fR 'a named_variant = \f[CB]'a\fR \f[CB]constraint\fR \f[CB]'a\fR = [< Type\.polymorphic_variant ]
226
226
.sp
227
227
\f[CB]type\fR 'a exact_object = \f[CB]'a\fR \f[CB]constraint\fR \f[CB]'a\fR = < a : int ; b : int >
228
228
.sp
···
236
236
.sp
237
237
\f[CB]type\fR extensible = \.\.
238
238
.sp
239
-
\f[CB]type\fR extensible +=
239
+
\f[CB]type\fR Type\.extensible +=
240
240
.br
241
241
.ti +2
242
242
| \f[CB]Extension\fR
···
254
254
\f[CB]type\fR mutually =
255
255
.br
256
256
.ti +2
257
-
| \f[CB]A\fR \f[CB]of\fR recursive
257
+
| \f[CB]A\fR \f[CB]of\fR Type\.recursive
258
258
.br
259
259
.sp
260
260
\f[CB]and\fR recursive =
261
261
.br
262
262
.ti +2
263
-
| \f[CB]B\fR \f[CB]of\fR mutually
263
+
| \f[CB]B\fR \f[CB]of\fR Type\.mutually
264
264
.br
265
265
.sp
266
266
\f[CB]exception\fR \f[CB]Foo\fR \f[CB]of\fR int * int
+1
-1
odoc/test/generators/markdown/Functor-F1.md
+1
-1
odoc/test/generators/markdown/Functor-F1.md
+1
-1
odoc/test/generators/markdown/Functor-F2.md
+1
-1
odoc/test/generators/markdown/Functor-F2.md
+1
-1
odoc/test/generators/markdown/Functor-F3.md
+1
-1
odoc/test/generators/markdown/Functor-F3.md
+1
-1
odoc/test/generators/markdown/Functor-F4.md
+1
-1
odoc/test/generators/markdown/Functor-F4.md
+1
-1
odoc/test/generators/markdown/Functor-module-type-S1.md
+1
-1
odoc/test/generators/markdown/Functor-module-type-S1.md
+6
-6
odoc/test/generators/markdown/Functor.md
+6
-6
odoc/test/generators/markdown/Functor.md
···
5
5
module type S = sig ... end
6
6
```
7
7
```
8
-
module type S1 = functor (_ : S) -> S
8
+
module type S1 = functor (_ : Functor.S) -> Functor.S
9
9
```
10
10
```
11
-
module F1 (Arg : S) : S
11
+
module F1 (Arg : Functor.S) : Functor.S
12
12
```
13
13
```
14
-
module F2 (Arg : S) : S with type t = Arg.t
14
+
module F2 (Arg : Functor.S) : Functor.S with type t = Arg.t
15
15
```
16
16
```
17
-
module F3 (Arg : S) : sig ... end
17
+
module F3 (Arg : Functor.S) : sig ... end
18
18
```
19
19
```
20
-
module F4 (Arg : S) : S
20
+
module F4 (Arg : Functor.S) : Functor.S
21
21
```
22
22
```
23
-
module F5 () : S
23
+
module F5 () : Functor.S
24
24
```
+2
-2
odoc/test/generators/markdown/Functor2-X.md
+2
-2
odoc/test/generators/markdown/Functor2-X.md
+2
-2
odoc/test/generators/markdown/Functor2-module-type-XF.md
+2
-2
odoc/test/generators/markdown/Functor2-module-type-XF.md
+5
-2
odoc/test/generators/markdown/Functor2.md
+5
-2
odoc/test/generators/markdown/Functor2.md
···
5
5
module type S = sig ... end
6
6
```
7
7
```
8
-
module X (Y : S) (Z : S) : sig ... end
8
+
module X (Y : Functor2.S) (Z : Functor2.S) : sig ... end
9
9
```
10
10
```
11
-
module type XF = functor (Y : S) -> functor (Z : S) -> sig ... end
11
+
module type XF =
12
+
functor (Y : Functor2.S) ->
13
+
functor (Z : Functor2.S) ->
14
+
sig ... end
12
15
```
+1
-1
odoc/test/generators/markdown/Functor_ml-Foo'.md
+1
-1
odoc/test/generators/markdown/Functor_ml-Foo'.md
+1
-1
odoc/test/generators/markdown/Include-module-type-Dorminant_Module.md
+1
-1
odoc/test/generators/markdown/Include-module-type-Dorminant_Module.md
+1
-1
odoc/test/generators/markdown/Include-module-type-Inherent_Module.md
+1
-1
odoc/test/generators/markdown/Include-module-type-Inherent_Module.md
+1
-1
odoc/test/generators/markdown/Include.md
+1
-1
odoc/test/generators/markdown/Include.md
+1
-1
odoc/test/generators/markdown/Include2-Y_include_doc.md
+1
-1
odoc/test/generators/markdown/Include2-Y_include_doc.md
+1
-1
odoc/test/generators/markdown/Include2-Y_include_synopsis.md
+1
-1
odoc/test/generators/markdown/Include2-Y_include_synopsis.md
+8
-22
odoc/test/generators/markdown/Labels.md
+8
-22
odoc/test/generators/markdown/Labels.md
···
16
16
Attached to type
17
17
18
18
```
19
-
val f : t
19
+
val f : Labels.t
20
20
```
21
21
Attached to value
22
22
23
23
```
24
-
val e : unit -> t
24
+
val e : unit -> Labels.t
25
25
```
26
26
Attached to external
27
27
···
43
43
type x = ..
44
44
```
45
45
```
46
-
type x +=
47
-
```
48
-
```
46
+
type Labels.x +=
49
47
| X
50
-
```
51
-
```
52
48
53
49
```
54
50
Attached to extension
55
51
56
52
```
57
-
module S := A
53
+
module S := Labels.A
58
54
```
59
55
Attached to module subst
60
56
61
57
```
62
-
type s := t
58
+
type s := Labels.t
63
59
```
64
60
Attached to type subst
65
61
66
62
```
67
-
type u =
68
-
```
69
-
```
70
-
| A'
71
-
```
72
-
Attached to constructor
73
-
74
-
```
63
+
type u =
64
+
| A' (** Attached to constructor *)
75
65
76
66
```
77
67
```
78
68
type v = {
79
-
```
80
-
`f : t;`
81
-
Attached to field
82
-
83
-
```
69
+
(** Attached to field *)
84
70
}
85
71
```
86
72
Testing that labels can be referenced
+1
-1
odoc/test/generators/markdown/Module-module-type-S7.md
+1
-1
odoc/test/generators/markdown/Module-module-type-S7.md
+8
-8
odoc/test/generators/markdown/Module.md
+8
-8
odoc/test/generators/markdown/Module.md
···
15
15
module type S1
16
16
```
17
17
```
18
-
module type S2 = S
18
+
module type S2 = Module.S
19
19
```
20
20
```
21
-
module type S3 = S with type t = int and type u = string
21
+
module type S3 = Module.S with type t = int and type u = string
22
22
```
23
23
```
24
-
module type S4 = S with type t := int
24
+
module type S4 = Module.S with type t := int
25
25
```
26
26
```
27
-
module type S5 = S with type 'a v := 'a list
27
+
module type S5 = Module.S with type 'a v := 'a list
28
28
```
29
29
```
30
30
type ('a, 'b) result
31
31
```
32
32
```
33
-
module type S6 = S with type ('a, 'b) w := ('a, 'b) result
33
+
module type S6 = Module.S with type ('a, 'b) w := ('a, 'b) Module.result
34
34
```
35
35
```
36
36
module M' : sig ... end
37
37
```
38
38
```
39
-
module type S7 = S with module M = M'
39
+
module type S7 = Module.S with module M = Module.M'
40
40
```
41
41
```
42
-
module type S8 = S with module M := M'
42
+
module type S8 = Module.S with module M := Module.M'
43
43
```
44
44
```
45
-
module type S9 = module type of M'
45
+
module type S9 = module type of Module.M'
46
46
```
47
47
```
48
48
module Mutually : sig ... end
+4
-4
odoc/test/generators/markdown/Module_type_alias.md
+4
-4
odoc/test/generators/markdown/Module_type_alias.md
···
10
10
module type B = functor (C : sig ... end) -> sig ... end
11
11
```
12
12
```
13
-
module type D = A
13
+
module type D = Module_type_alias.A
14
14
```
15
15
```
16
-
module type E = functor (F : sig ... end) -> B
16
+
module type E = functor (F : sig ... end) -> Module_type_alias.B
17
17
```
18
18
```
19
-
module type G = functor (H : sig ... end) -> D
19
+
module type G = functor (H : sig ... end) -> Module_type_alias.D
20
20
```
21
21
```
22
-
module type I = B
22
+
module type I = Module_type_alias.B
23
23
```
+1
-1
odoc/test/generators/markdown/Module_type_of-T.md
+1
-1
odoc/test/generators/markdown/Module_type_of-T.md
+1
-1
odoc/test/generators/markdown/Module_type_of.md
+1
-1
odoc/test/generators/markdown/Module_type_of.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Basic-module-type-a.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Basic-module-type-a.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Basic-module-type-c.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Basic-module-type-c.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Basic-module-type-with_.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Basic-module-type-with_.md
+6
-3
odoc/test/generators/markdown/Module_type_subst-Basic.md
+6
-3
odoc/test/generators/markdown/Module_type_subst-Basic.md
···
5
5
module type u = sig ... end
6
6
```
7
7
```
8
-
module type with_ = u with module type T = s
8
+
module type with_ =
9
+
Module_type_subst.Basic.u with module type T = Module_type_subst.s
9
10
```
10
11
```
11
12
module type u2 = sig ... end
12
13
```
13
14
```
14
-
module type with_2 = u2 with module type T = sig ... end
15
+
module type with_2 =
16
+
Module_type_subst.Basic.u2 with module type T = sig ... end
15
17
```
16
18
```
17
19
module type a = sig ... end
18
20
```
19
21
```
20
-
module type c = a with module type b := s
22
+
module type c =
23
+
Module_type_subst.Basic.a with module type b := Module_type_subst.s
21
24
```
+1
-1
odoc/test/generators/markdown/Module_type_subst-Local-module-type-local.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Local-module-type-local.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Local.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Local.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Nested-module-type-with_-N.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Nested-module-type-with_-N.md
+4
-2
odoc/test/generators/markdown/Module_type_subst-Nested.md
+4
-2
odoc/test/generators/markdown/Module_type_subst-Nested.md
···
5
5
module type nested = sig ... end
6
6
```
7
7
```
8
-
module type with_ = nested with module type N.t = s
8
+
module type with_ =
9
+
Module_type_subst.Nested.nested with module type N.t = Module_type_subst.s
9
10
```
10
11
```
11
-
module type with_subst = nested with module type N.t := s
12
+
module type with_subst =
13
+
Module_type_subst.Nested.nested with module type N.t := Module_type_subst.s
12
14
```
+1
-5
odoc/test/generators/markdown/Module_type_subst-Structural-module-type-u-module-type-a-module-type-b-module-type-c.md
+1
-5
odoc/test/generators/markdown/Module_type_subst-Structural-module-type-u-module-type-a-module-type-b-module-type-c.md
+1
-5
odoc/test/generators/markdown/Module_type_subst-Structural-module-type-w-module-type-a-module-type-b-module-type-c.md
+1
-5
odoc/test/generators/markdown/Module_type_subst-Structural-module-type-w-module-type-a-module-type-b-module-type-c.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Structural.md
+1
-1
odoc/test/generators/markdown/Module_type_subst-Structural.md
+1
-1
odoc/test/generators/markdown/Nested-F-argument-1-Arg1.md
+1
-1
odoc/test/generators/markdown/Nested-F-argument-1-Arg1.md
+1
-1
odoc/test/generators/markdown/Nested-F.md
+1
-1
odoc/test/generators/markdown/Nested-F.md
+1
-1
odoc/test/generators/markdown/Nested-X.md
+1
-1
odoc/test/generators/markdown/Nested-X.md
+1
-1
odoc/test/generators/markdown/Nested.md
+1
-1
odoc/test/generators/markdown/Nested.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-E.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-E.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-A.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-A.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-B.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-B.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-D.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-D.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-E.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Foo-E.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-P1-Y.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-P1-Y.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-P2-Z.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-P2-Z.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Std.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Aliases-Std.md
+7
-7
odoc/test/generators/markdown/Ocamlary-Aliases.md
+7
-7
odoc/test/generators/markdown/Ocamlary-Aliases.md
···
13
13
type tata = Foo.A.t
14
14
```
15
15
```
16
-
type tbtb = Foo.B.t
16
+
type tbtb = Ocamlary.Aliases.Foo.B.t
17
17
```
18
18
```
19
19
type tete
···
22
22
type tata' = A'.t
23
23
```
24
24
```
25
-
type tete2 = Foo.E.t
25
+
type tete2 = Ocamlary.Aliases.Foo.E.t
26
26
```
27
27
```
28
28
module Std : sig ... end
···
36
36
Just for giggle, let's see what happens when we include [`Foo`](./Ocamlary-Aliases-Foo.md).
37
37
38
38
```
39
-
module A = Foo.A
39
+
module A = Ocamlary.Aliases.Foo.A
40
40
```
41
41
```
42
-
module B = Foo.B
42
+
module B = Ocamlary.Aliases.Foo.B
43
43
```
44
44
```
45
-
module C = Foo.C
45
+
module C = Ocamlary.Aliases.Foo.C
46
46
```
47
47
```
48
-
module D = Foo.D
48
+
module D = Ocamlary.Aliases.Foo.D
49
49
```
50
50
```
51
51
module E : sig ... end
···
62
62
module P2 : sig ... end
63
63
```
64
64
```
65
-
module X1 = P2.Z
65
+
module X1 = Ocamlary.Aliases.P2.Z
66
66
```
67
67
```
68
68
module X2 = P2.Z
+3
-1
odoc/test/generators/markdown/Ocamlary-CanonicalTest-Base-List.md
+3
-1
odoc/test/generators/markdown/Ocamlary-CanonicalTest-Base-List.md
+3
-1
odoc/test/generators/markdown/Ocamlary-CanonicalTest-Base_Tests-C.md
+3
-1
odoc/test/generators/markdown/Ocamlary-CanonicalTest-Base_Tests-C.md
+6
-4
odoc/test/generators/markdown/Ocamlary-CanonicalTest-Base_Tests.md
+6
-4
odoc/test/generators/markdown/Ocamlary-CanonicalTest-Base_Tests.md
···
2
2
# Module `CanonicalTest.Base_Tests`
3
3
4
4
```
5
-
module C : module type of Base.List
5
+
module C : module type of Ocamlary.CanonicalTest.Base.List
6
6
```
7
7
```
8
-
module L = Base.List
8
+
module L = Ocamlary.CanonicalTest.Base.List
9
9
```
10
10
```
11
11
val foo : int L.t -> float L.t
12
12
```
13
13
```
14
-
val bar : 'a Base.List.t -> 'a Base.List.t
14
+
val bar :
15
+
'a Ocamlary.CanonicalTest.Base.List.t ->
16
+
'a Ocamlary.CanonicalTest.Base.List.t
15
17
```
16
18
```
17
-
val baz : 'a Base.List.t -> unit
19
+
val baz : 'a Ocamlary.CanonicalTest.Base.List.t -> unit
18
20
```
+4
-2
odoc/test/generators/markdown/Ocamlary-CanonicalTest-List_modif.md
+4
-2
odoc/test/generators/markdown/Ocamlary-CanonicalTest-List_modif.md
+3
-1
odoc/test/generators/markdown/Ocamlary-CanonicalTest.md
+3
-1
odoc/test/generators/markdown/Ocamlary-CanonicalTest.md
+1
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA.md
+2
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule.md
+2
-1
odoc/test/generators/markdown/Ocamlary-CollectionModule.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep1-X.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep1-X.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep2-argument-1-Arg-X.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep2-argument-1-Arg-X.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep4-module-type-S.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep4-module-type-S.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep4.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep4.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5-Z.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5-Z.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5-argument-1-Arg-module-type-S.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5-argument-1-Arg-module-type-S.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5-argument-1-Arg.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5-argument-1-Arg.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep5.md
+2
-2
odoc/test/generators/markdown/Ocamlary-Dep6-X.md
+2
-2
odoc/test/generators/markdown/Ocamlary-Dep6-X.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep6-module-type-T.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep6-module-type-T.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep6.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep6.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep7-M.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep7-M.md
+2
-2
odoc/test/generators/markdown/Ocamlary-Dep7-argument-1-Arg-X.md
+2
-2
odoc/test/generators/markdown/Ocamlary-Dep7-argument-1-Arg-X.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep7-argument-1-Arg-module-type-T.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep7-argument-1-Arg-module-type-T.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep7-argument-1-Arg.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Dep7-argument-1-Arg.md
+1
-5
odoc/test/generators/markdown/Ocamlary-ExtMod.md
+1
-5
odoc/test/generators/markdown/Ocamlary-ExtMod.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf.md
+1
-1
odoc/test/generators/markdown/Ocamlary-FunctorTypeOf.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection-argument-1-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection.md
+1
-1
odoc/test/generators/markdown/Ocamlary-Recollection.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With3.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With3.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With4.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With4.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With5.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With5.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With6-module-type-T-M.md
+1
-1
odoc/test/generators/markdown/Ocamlary-With6-module-type-T-M.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A-Q.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-A.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B-Q.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-B.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C-Q.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM-C.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-MMM.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-RECOLLECTION.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-RECOLLECTION.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.md
+2
-2
odoc/test/generators/markdown/Ocamlary-module-type-RecollectionModule.md
+2
-2
odoc/test/generators/markdown/Ocamlary-module-type-RecollectionModule.md
···
2
2
# Module type `Ocamlary.RecollectionModule`
3
3
4
4
```
5
-
type collection = CollectionModule.element list
5
+
type collection = Ocamlary.CollectionModule.element list
6
6
```
7
7
```
8
-
type element = CollectionModule.collection
8
+
type element = Ocamlary.CollectionModule.collection
9
9
```
10
10
```
11
11
module InnerModuleA : sig ... end
+1
-5
odoc/test/generators/markdown/Ocamlary-module-type-TypeExt.md
+1
-5
odoc/test/generators/markdown/Ocamlary-module-type-TypeExt.md
+2
-6
odoc/test/generators/markdown/Ocamlary-module-type-TypeExtPruned.md
+2
-6
odoc/test/generators/markdown/Ocamlary-module-type-TypeExtPruned.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-With11.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-With11.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-With8-M-N.md
+1
-1
odoc/test/generators/markdown/Ocamlary-module-type-With8-M-N.md
+4
-2
odoc/test/generators/markdown/Ocamlary-module-type-With8-M.md
+4
-2
odoc/test/generators/markdown/Ocamlary-module-type-With8-M.md
···
2
2
# Module `With8.M`
3
3
4
4
```
5
-
module type S = With5.S
5
+
module type S = Ocamlary.With5.S
6
6
```
7
7
```
8
-
module N : module type of struct include With5.N end with type t = With5.N.t
8
+
module N :
9
+
module type of struct include Ocamlary.With5.N end
10
+
with type t = Ocamlary.With5.N.t
9
11
```
+3
-1
odoc/test/generators/markdown/Ocamlary-module-type-With8.md
+3
-1
odoc/test/generators/markdown/Ocamlary-module-type-With8.md
+102
-272
odoc/test/generators/markdown/Ocamlary.md
+102
-272
odoc/test/generators/markdown/Ocamlary.md
···
86
86
## Section 9000
87
87
88
88
```
89
-
module EmptyAlias = Empty
89
+
module EmptyAlias = Ocamlary.Empty
90
90
```
91
91
A plain module alias of `Empty`
92
92
···
99
99
A plain, empty module signature
100
100
101
101
```
102
-
module type EmptySigAlias = EmptySig
102
+
module type EmptySigAlias = Ocamlary.EmptySig
103
103
```
104
104
A plain, empty module signature alias of
105
105
106
106
```
107
-
module ModuleWithSignature : EmptySig
107
+
module ModuleWithSignature : Ocamlary.EmptySig
108
108
```
109
109
A plain module of a signature of [`EmptySig`](./Ocamlary-module-type-EmptySig.md) (reference)
110
110
111
111
```
112
-
module ModuleWithSignatureAlias : EmptySigAlias
112
+
module ModuleWithSignatureAlias : Ocamlary.EmptySigAlias
113
113
```
114
114
A plain module with an alias signature
115
115
···
179
179
parameter x the x coordinate
180
180
returns the y coordinate
181
181
```
182
-
val fun_fun_fun : ((int, int) a_function, (unit, unit) a_function) a_function
182
+
val fun_fun_fun :
183
+
((int, int) Ocamlary.a_function, (unit, unit) Ocamlary.a_function)
184
+
Ocamlary.a_function
183
185
```
184
186
```
185
187
val fun_maybe : ?yes:unit -> unit -> int
···
272
274
This comment is for `CollectionModule`.
273
275
274
276
```
275
-
module type COLLECTION = module type of CollectionModule
277
+
module type COLLECTION = module type of Ocamlary.CollectionModule
276
278
```
277
279
module type of
278
280
279
281
```
280
282
module Recollection
281
-
(C : COLLECTION) :
282
-
COLLECTION
283
+
(C : Ocamlary.COLLECTION) :
284
+
Ocamlary.COLLECTION
283
285
with type collection = C.element list
284
286
and type element = C.collection
285
287
```
···
289
291
module type MMM = sig ... end
290
292
```
291
293
```
292
-
module type RECOLLECTION = MMM with module C = Recollection(CollectionModule)
294
+
module type RECOLLECTION =
295
+
Ocamlary.MMM with module C = Ocamlary.Recollection(Ocamlary.CollectionModule)
293
296
```
294
297
```
295
298
module type RecollectionModule = sig ... end
···
307
310
308
311
```
309
312
module FunctorTypeOf
310
-
(Collection : module type of CollectionModule) :
313
+
(Collection : module type of Ocamlary.CollectionModule) :
311
314
sig ... end
312
315
```
313
316
This comment is for `FunctorTypeOf`.
···
331
334
332
335
```
333
336
type record = {
334
-
```
335
-
`field1 : int;`
336
-
This comment is for `field1`.
337
-
338
-
`field2 : int;`
339
-
This comment is for `field2`.
340
-
341
-
```
337
+
(** This comment is for field1. *)
338
+
(** This comment is for field2. *)
342
339
}
343
340
```
344
341
This comment is for `record`.
···
347
344
348
345
```
349
346
type mutable_record = {
350
-
```
351
-
`mutable a : int;`
352
-
`a` is first and mutable
353
-
354
-
`b : unit;`
355
-
`b` is second and immutable
356
-
357
-
`mutable c : int;`
358
-
`c` is third and mutable
359
-
360
-
```
347
+
(** a is first and mutable *)
348
+
(** b is second and immutable *)
349
+
(** c is third and mutable *)
361
350
}
362
351
```
363
352
```
364
353
type universe_record = {
365
-
```
366
-
`nihilate : 'a. 'a -> unit;`
367
-
```
368
-
}
369
-
```
370
-
```
371
-
type variant =
372
-
```
373
-
```
374
-
| TagA
375
-
```
376
-
This comment is for `TagA`.
377
354
355
+
}
378
356
```
379
-
| ConstrB of int
380
357
```
381
-
This comment is for `ConstrB`.
382
-
383
-
```
384
-
| ConstrC of int * int
385
-
```
386
-
This comment is for binary `ConstrC`.
387
-
388
-
```
389
-
| ConstrD of int * int
390
-
```
391
-
This comment is for unary `ConstrD` of binary tuple.
392
-
393
-
```
358
+
type variant =
359
+
| TagA (** This comment is for TagA. *)
360
+
| ConstrB of int (** This comment is for ConstrB. *)
361
+
| ConstrC of int * int (** This comment is for binary ConstrC. *)
362
+
| ConstrD of int * int (** This comment is for unary ConstrD of binary tuple. *)
394
363
395
364
```
396
365
This comment is for `variant`.
···
398
367
This comment is also for `variant`.
399
368
400
369
```
401
-
type poly_variant = [
402
-
```
403
-
```
370
+
type poly_variant = [
404
371
| `TagA
405
-
```
406
-
```
407
372
| `ConstrB of int
408
-
```
409
-
```
410
-
]
373
+
]
411
374
```
412
375
This comment is for `poly_variant`.
413
376
414
377
Wow\! It was a polymorphic variant\!
415
378
416
379
```
417
-
type (_, _) full_gadt =
418
-
```
419
-
```
420
-
| Tag : (unit, unit) full_gadt
421
-
```
422
-
```
423
-
| First : 'a -> ('a, unit) full_gadt
424
-
```
425
-
```
426
-
| Second : 'a -> (unit, 'a) full_gadt
427
-
```
428
-
```
429
-
| Exist : 'a * 'b -> ('b, unit) full_gadt
430
-
```
431
-
```
380
+
type (_, _) full_gadt =
381
+
| Tag : (unit, unit) Ocamlary.full_gadt
382
+
| First : 'a -> ('a, unit) Ocamlary.full_gadt
383
+
| Second : 'a -> (unit, 'a) Ocamlary.full_gadt
384
+
| Exist : 'a * 'b -> ('b, unit) Ocamlary.full_gadt
432
385
433
386
```
434
387
This comment is for `full_gadt`.
···
436
389
Wow\! It was a GADT\!
437
390
438
391
```
439
-
type 'a partial_gadt =
440
-
```
441
-
```
442
-
| AscribeTag : 'a partial_gadt
443
-
```
444
-
```
445
-
| OfTag of 'a partial_gadt
446
-
```
447
-
```
448
-
| ExistGadtTag : ('a -> 'b) -> 'a partial_gadt
449
-
```
450
-
```
392
+
type 'a partial_gadt =
393
+
| AscribeTag : 'a Ocamlary.partial_gadt
394
+
| OfTag of 'a Ocamlary.partial_gadt
395
+
| ExistGadtTag : ('a -> 'b) -> 'a Ocamlary.partial_gadt
451
396
452
397
```
453
398
This comment is for `partial_gadt`.
···
455
400
Wow\! It was a mixed GADT\!
456
401
457
402
```
458
-
type alias = variant
403
+
type alias = Ocamlary.variant
459
404
```
460
405
This comment is for `alias`.
461
406
462
407
```
463
-
type tuple = (alias * alias) * alias * (alias * alias)
408
+
type tuple =
409
+
(Ocamlary.alias * Ocamlary.alias)
410
+
* Ocamlary.alias
411
+
* (Ocamlary.alias * Ocamlary.alias)
464
412
```
465
413
This comment is for `tuple`.
466
414
467
415
```
468
-
type variant_alias = variant =
469
-
```
470
-
```
416
+
type variant_alias = Ocamlary.variant =
471
417
| TagA
472
-
```
473
-
```
474
418
| ConstrB of int
475
-
```
476
-
```
477
419
| ConstrC of int * int
478
-
```
479
-
```
480
420
| ConstrD of int * int
481
-
```
482
-
```
483
421
484
422
```
485
423
This comment is for `variant_alias`.
486
424
487
425
```
488
-
type record_alias = record = {
489
-
```
490
-
`field1 : int;`
491
-
`field2 : int;`
492
-
```
426
+
type record_alias = Ocamlary.record = {
427
+
428
+
493
429
}
494
430
```
495
431
This comment is for `record_alias`.
496
432
497
433
```
498
-
type poly_variant_union = [
499
-
```
500
-
```
501
-
| poly_variant
502
-
```
503
-
```
434
+
type poly_variant_union = [
435
+
| Ocamlary.poly_variant
504
436
| `TagC
505
-
```
506
-
```
507
-
]
437
+
]
508
438
```
509
439
This comment is for `poly_variant_union`.
510
440
511
441
```
512
-
type 'a poly_poly_variant = [
513
-
```
514
-
```
442
+
type 'a poly_poly_variant = [
515
443
| `TagA of 'a
516
-
```
517
-
```
518
-
]
519
-
```
520
-
```
521
-
type ('a, 'b) bin_poly_poly_variant = [
444
+
]
522
445
```
523
446
```
447
+
type ('a, 'b) bin_poly_poly_variant = [
524
448
| `TagA of 'a
525
-
```
526
-
```
527
449
| `ConstrB of 'b
528
-
```
529
-
```
530
-
]
450
+
]
531
451
```
532
452
```
533
453
type 'a open_poly_variant = [> `TagA ] as 'a
···
536
456
type 'a open_poly_variant2 = [> `ConstrB of int ] as 'a
537
457
```
538
458
```
539
-
type 'a open_poly_variant_alias = 'a open_poly_variant open_poly_variant2
459
+
type 'a open_poly_variant_alias =
460
+
'a Ocamlary.open_poly_variant Ocamlary.open_poly_variant2
540
461
```
541
462
```
542
463
type 'a poly_fun = ([> `ConstrB of int ] as 'a) -> 'a
···
551
472
type 'a clopen_poly_variant = [< `One | `Two of int | `Three Two Three ] as 'a
552
473
```
553
474
```
554
-
type nested_poly_variant = [
555
-
```
556
-
```
475
+
type nested_poly_variant = [
557
476
| `A
558
-
```
559
-
```
560
477
| `B of [ `B1 | `B2 ]
561
-
```
562
-
```
563
478
| `C
564
-
```
565
-
```
566
479
| `D of [ `D1 of [ `D1a ] ]
567
-
```
568
-
```
569
-
]
570
-
```
571
-
```
572
-
type ('a, 'b) full_gadt_alias = ('a, 'b) full_gadt =
573
-
```
574
-
```
575
-
| Tag : (unit, unit) full_gadt_alias
480
+
]
576
481
```
577
482
```
578
-
| First : 'a -> ('a, unit) full_gadt_alias
579
-
```
580
-
```
581
-
| Second : 'a -> (unit, 'a) full_gadt_alias
582
-
```
583
-
```
584
-
| Exist : 'a * 'b -> ('b, unit) full_gadt_alias
585
-
```
586
-
```
483
+
type ('a, 'b) full_gadt_alias = ('a, 'b) Ocamlary.full_gadt =
484
+
| Tag : (unit, unit) Ocamlary.full_gadt_alias
485
+
| First : 'a -> ('a, unit) Ocamlary.full_gadt_alias
486
+
| Second : 'a -> (unit, 'a) Ocamlary.full_gadt_alias
487
+
| Exist : 'a * 'b -> ('b, unit) Ocamlary.full_gadt_alias
587
488
588
489
```
589
490
This comment is for `full_gadt_alias`.
590
491
591
492
```
592
-
type 'a partial_gadt_alias = 'a partial_gadt =
593
-
```
594
-
```
595
-
| AscribeTag : 'a partial_gadt_alias
596
-
```
597
-
```
598
-
| OfTag of 'a partial_gadt_alias
599
-
```
600
-
```
601
-
| ExistGadtTag : ('a -> 'b) -> 'a partial_gadt_alias
602
-
```
603
-
```
493
+
type 'a partial_gadt_alias = 'a Ocamlary.partial_gadt =
494
+
| AscribeTag : 'a Ocamlary.partial_gadt_alias
495
+
| OfTag of 'a Ocamlary.partial_gadt_alias
496
+
| ExistGadtTag : ('a -> 'b) -> 'a Ocamlary.partial_gadt_alias
604
497
605
498
```
606
499
This comment is for `partial_gadt_alias`.
···
611
504
This comment is for [`Exn_arrow`](./#exception-Exn_arrow).
612
505
613
506
```
614
-
type mutual_constr_a =
615
-
```
616
-
```
507
+
type mutual_constr_a =
617
508
| A
618
-
```
619
-
```
620
-
| B_ish of mutual_constr_b
621
-
```
622
-
This comment is between [`mutual_constr_a`](./#type-mutual_constr_a) and [`mutual_constr_b`](./#type-mutual_constr_b).
623
-
624
-
```
509
+
| B_ish of Ocamlary.mutual_constr_b (** This comment is between mutual_constr_a and mutual_constr_b. *)
625
510
626
511
```
627
512
This comment is for [`mutual_constr_a`](./#type-mutual_constr_a) then [`mutual_constr_b`](./#type-mutual_constr_b).
628
513
629
514
```
630
-
and mutual_constr_b =
631
-
```
632
-
```
515
+
and mutual_constr_b =
633
516
| B
634
-
```
635
-
```
636
-
| A_ish of mutual_constr_a
637
-
```
638
-
This comment must be here for the next to associate correctly.
639
-
640
-
```
517
+
| A_ish of Ocamlary.mutual_constr_a (** This comment must be here for the next to associate correctly. *)
641
518
642
519
```
643
520
This comment is for [`mutual_constr_b`](./#type-mutual_constr_b) then [`mutual_constr_a`](./#type-mutual_constr_a).
644
521
645
522
```
646
-
type rec_obj = < f : int ; g : unit -> unit ; h : rec_obj >
523
+
type rec_obj = < f : int ; g : unit -> unit ; h : Ocamlary.rec_obj >
647
524
```
648
525
```
649
526
type 'a open_obj = < f : int ; g : unit -> unit.. > as 'a
···
666
543
A mystery wrapped in an ellipsis
667
544
668
545
```
669
-
type ext +=
670
-
```
671
-
```
546
+
type Ocamlary.ext +=
672
547
| ExtA
673
-
```
674
-
```
675
548
676
549
```
677
550
```
678
-
type ext +=
679
-
```
680
-
```
551
+
type Ocamlary.ext +=
681
552
| ExtB
682
-
```
683
-
```
684
553
685
554
```
686
555
```
687
-
type ext +=
688
-
```
689
-
```
556
+
type Ocamlary.ext +=
690
557
| ExtC of unit
691
-
```
692
-
```
693
-
| ExtD of ext
694
-
```
695
-
```
558
+
| ExtD of Ocamlary.ext
696
559
697
560
```
698
561
```
699
-
type ext +=
700
-
```
701
-
```
562
+
type Ocamlary.ext +=
702
563
| ExtE
703
-
```
704
-
```
705
564
706
565
```
707
566
```
708
-
type ext += private
709
-
```
710
-
```
567
+
type Ocamlary.ext += private
711
568
| ExtF
712
-
```
713
-
```
714
569
715
570
```
716
571
```
···
719
574
'a poly\_ext
720
575
721
576
```
722
-
type poly_ext +=
723
-
```
724
-
```
577
+
type Ocamlary.poly_ext +=
725
578
| Foo of 'b
726
-
```
727
-
```
728
-
| Bar of 'b * 'b
729
-
```
730
-
'b poly\_ext
579
+
| Bar of 'b * 'b (** 'b poly_ext *)
731
580
732
581
```
733
-
734
582
```
735
-
```
736
-
type poly_ext +=
737
-
```
738
-
```
739
-
| Quux of 'c
740
-
```
741
-
'c poly\_ext
742
-
743
-
```
583
+
type Ocamlary.poly_ext +=
584
+
| Quux of 'c (** 'c poly_ext *)
744
585
745
586
```
746
587
```
747
588
module ExtMod : sig ... end
748
589
```
749
590
```
750
-
type ExtMod.t +=
751
-
```
752
-
```
753
-
| ZzzTop0
754
-
```
755
-
It's got the rock
591
+
type Ocamlary.ExtMod.t +=
592
+
| ZzzTop0 (** It's got the rock *)
756
593
757
594
```
758
-
759
595
```
760
-
```
761
-
type ExtMod.t +=
762
-
```
763
-
```
764
-
| ZzzTop of unit
765
-
```
766
-
and it packs a unit.
767
-
768
-
```
596
+
type Ocamlary.ExtMod.t +=
597
+
| ZzzTop of unit (** and it packs a unit. *)
769
598
770
599
```
771
600
```
···
774
603
Rotate keys on my mark...
775
604
776
605
```
777
-
type my_mod = (module COLLECTION)
606
+
type my_mod = (module Ocamlary.COLLECTION)
778
607
```
779
608
A brown paper package tied up with string
780
609
···
815
644
module Dep5 (Arg : sig ... end) : sig ... end
816
645
```
817
646
```
818
-
type dep2 = Dep5(Dep4).Z.X.b
647
+
type dep2 = Ocamlary.Dep5(Ocamlary.Dep4).Z.X.b
819
648
```
820
649
```
821
650
type dep3 = Dep5(Dep4).Z.Y.a
···
827
656
module Dep7 (Arg : sig ... end) : sig ... end
828
657
```
829
658
```
830
-
type dep4 = Dep7(Dep6).M.Y.d
659
+
type dep4 = Ocamlary.Dep7(Ocamlary.Dep6).M.Y.d
831
660
```
832
661
```
833
662
module Dep8 : sig ... end
···
836
665
module Dep9 (X : sig ... end) : sig ... end
837
666
```
838
667
```
839
-
module type Dep10 = Dep9(Dep8).T with type t = int
668
+
module type Dep10 = Ocamlary.Dep9(Ocamlary.Dep8).T with type t = int
840
669
```
841
670
```
842
671
module Dep11 : sig ... end
···
845
674
module Dep12 (Arg : sig ... end) : sig ... end
846
675
```
847
676
```
848
-
module Dep13 : Dep12(Dep11).T
677
+
module Dep13 : Ocamlary.Dep12(Ocamlary.Dep11).T
849
678
```
850
679
```
851
-
type dep5 = Dep13.c
680
+
type dep5 = Ocamlary.Dep13.c
852
681
```
853
682
```
854
683
module type With1 = sig ... end
···
857
686
module With2 : sig ... end
858
687
```
859
688
```
860
-
module With3 : With1 with module M = With2
689
+
module With3 : Ocamlary.With1 with module M = Ocamlary.With2
861
690
```
862
691
```
863
-
type with1 = With3.N.t
692
+
type with1 = Ocamlary.With3.N.t
864
693
```
865
694
```
866
-
module With4 : With1 with module M := With2
695
+
module With4 : Ocamlary.With1 with module M := Ocamlary.With2
867
696
```
868
697
```
869
-
type with2 = With4.N.t
698
+
type with2 = Ocamlary.With4.N.t
870
699
```
871
700
```
872
701
module With5 : sig ... end
···
879
708
```
880
709
```
881
710
module type With8 =
882
-
With7(With6).T with module M = With5 and type M.N.t = With5.N.t
711
+
Ocamlary.With7(Ocamlary.With6).T
712
+
with module M = Ocamlary.With5
713
+
and type M.N.t = Ocamlary.With5.N.t
883
714
```
884
715
```
885
716
module With9 : sig ... end
···
888
719
module With10 : sig ... end
889
720
```
890
721
```
891
-
module type With11 = With7(With10).T with module M = With9 and type N.t = int
722
+
module type With11 =
723
+
Ocamlary.With7(Ocamlary.With10).T
724
+
with module M = Ocamlary.With9
725
+
and type N.t = int
892
726
```
893
727
```
894
728
module type NestedInclude1 = sig ... end
···
995
829
type new_t = ..
996
830
```
997
831
```
998
-
type new_t +=
999
-
```
1000
-
```
832
+
type Ocamlary.new_t +=
1001
833
| C
1002
-
```
1003
-
```
1004
834
1005
835
```
1006
836
```
1007
-
module type TypeExtPruned = TypeExt with type t := new_t
837
+
module type TypeExtPruned = Ocamlary.TypeExt with type t := Ocamlary.new_t
1008
838
```
1009
839
```
1010
840
module Op : sig ... end
+8
odoc/test/generators/markdown/Recent-X.md
+8
odoc/test/generators/markdown/Recent-X.md
···
2
2
# Module `Recent.X`
3
3
4
4
```
5
+
<<<<<<< HEAD
5
6
module L := Z.Y
7
+
=======
8
+
module L := Recent.Z.Y
9
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
6
10
```
7
11
```
8
12
type t = int L.X.t
···
11
15
type u := int
12
16
```
13
17
```
18
+
<<<<<<< HEAD
14
19
type v = u L.X.t
20
+
=======
21
+
type v = Recent.X.u L.X.t
22
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
15
23
```
+7
odoc/test/generators/markdown/Recent-module-type-PolyS.md
+7
odoc/test/generators/markdown/Recent-module-type-PolyS.md
+4
odoc/test/generators/markdown/Recent-module-type-S1.md
+4
odoc/test/generators/markdown/Recent-module-type-S1.md
+45
odoc/test/generators/markdown/Recent.md
+45
odoc/test/generators/markdown/Recent.md
···
5
5
module type S = sig ... end
6
6
```
7
7
```
8
+
<<<<<<< HEAD
8
9
module type S1 = functor (_ : S) -> S
9
10
```
10
11
```
···
78
79
79
80
```
80
81
]
82
+
=======
83
+
module type S1 = functor (_ : Recent.S) -> Recent.S
84
+
```
85
+
```
86
+
type variant =
87
+
| A
88
+
| B of int
89
+
| C (** foo *)
90
+
| D (** bar *)
91
+
| E of {
92
+
a : int;
93
+
}
94
+
95
+
```
96
+
```
97
+
type _ gadt =
98
+
| A : int Recent.gadt
99
+
| B : int -> string Recent.gadt (** foo *)
100
+
| C : {
101
+
a : int;
102
+
} -> unit Recent.gadt
103
+
104
+
```
105
+
```
106
+
type polymorphic_variant = [
107
+
| `A
108
+
| `B of int
109
+
| `C (** foo *)
110
+
| `D (** bar *)
111
+
]
112
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
81
113
```
82
114
```
83
115
type empty_variant = |
···
86
118
type nonrec nonrec_ = int
87
119
```
88
120
```
121
+
<<<<<<< HEAD
89
122
type empty_conj =
90
123
```
91
124
```
···
101
134
| X : [< `X of int & [< `B of int & float ] ] -> conj
102
135
```
103
136
```
137
+
=======
138
+
type empty_conj =
139
+
| X : [< `X of & 'a & int * float ] -> Recent.empty_conj
140
+
141
+
```
142
+
```
143
+
type conj =
144
+
| X : [< `X of int & [< `B of int & float ] ] -> Recent.conj
145
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
104
146
105
147
```
106
148
```
···
117
159
```
118
160
```
119
161
module type PolyS = sig ... end
162
+
<<<<<<< HEAD
120
163
```
121
164
```
122
165
type +-'a phantom
123
166
```
124
167
```
125
168
val f : (x:int * y:int) phantom -> unit
169
+
=======
170
+
>>>>>>> baf34b7f4 (Add markdown to generator tests)
126
171
```
+1
-5
odoc/test/generators/markdown/Recent_impl-B.md
+1
-5
odoc/test/generators/markdown/Recent_impl-B.md
+1
-5
odoc/test/generators/markdown/Recent_impl-Foo-A.md
+1
-5
odoc/test/generators/markdown/Recent_impl-Foo-A.md
+1
-5
odoc/test/generators/markdown/Recent_impl-Foo-B.md
+1
-5
odoc/test/generators/markdown/Recent_impl-Foo-B.md
+1
-1
odoc/test/generators/markdown/Recent_impl.md
+1
-1
odoc/test/generators/markdown/Recent_impl.md
+16
-52
odoc/test/generators/markdown/Stop_dead_link_doc.md
+16
-52
odoc/test/generators/markdown/Stop_dead_link_doc.md
···
5
5
module Foo : sig ... end
6
6
```
7
7
```
8
-
type foo =
9
-
```
10
-
```
11
-
| Bar of Foo.t
12
-
```
13
-
```
8
+
type foo =
9
+
| Bar of Stop_dead_link_doc.Foo.t
14
10
15
11
```
16
12
```
17
-
type bar =
18
-
```
19
-
```
13
+
type bar =
20
14
| Bar of {
21
-
```
22
-
`field : Foo.t;`
23
-
```
15
+
24
16
}
25
-
```
26
-
```
27
17
28
18
```
29
19
```
30
-
type foo_ =
31
-
```
32
-
```
33
-
| Bar_ of int * Foo.t * int
34
-
```
35
-
```
20
+
type foo_ =
21
+
| Bar_ of int * Stop_dead_link_doc.Foo.t * int
36
22
37
23
```
38
24
```
39
-
type bar_ =
40
-
```
41
-
```
42
-
| Bar__ of Foo.t option
43
-
```
44
-
```
25
+
type bar_ =
26
+
| Bar__ of Stop_dead_link_doc.Foo.t option
45
27
46
28
```
47
29
```
48
-
type another_foo =
49
-
```
50
-
```
51
-
| Bar of Another_Foo.t
52
-
```
53
-
```
30
+
type another_foo =
31
+
| Bar of Stop_dead_link_doc.Another_Foo.t
54
32
55
33
```
56
34
```
57
-
type another_bar =
58
-
```
59
-
```
35
+
type another_bar =
60
36
| Bar of {
61
-
```
62
-
`field : Another_Foo.t;`
63
-
```
37
+
64
38
}
65
-
```
66
-
```
67
39
68
40
```
69
41
```
70
-
type another_foo_ =
71
-
```
72
-
```
73
-
| Bar_ of int * Another_Foo.t * int
74
-
```
75
-
```
42
+
type another_foo_ =
43
+
| Bar_ of int * Stop_dead_link_doc.Another_Foo.t * int
76
44
77
45
```
78
46
```
79
-
type another_bar_ =
80
-
```
81
-
```
82
-
| Bar__ of Another_Foo.t option
83
-
```
84
-
```
47
+
type another_bar_ =
48
+
| Bar__ of Stop_dead_link_doc.Another_Foo.t option
85
49
86
50
```
+1
-1
odoc/test/generators/markdown/Toplevel_comments.md
+1
-1
odoc/test/generators/markdown/Toplevel_comments.md
+46
-130
odoc/test/generators/markdown/Type.md
+46
-130
odoc/test/generators/markdown/Type.md
···
43
43
type nested_pair = (int * int) * int
44
44
```
45
45
```
46
-
type instance = int constructor
46
+
type instance = int Type.constructor
47
47
```
48
48
```
49
49
type long =
50
-
labeled_higher_order ->
51
-
[ `Bar | `Baz of triple ] ->
52
-
pair ->
53
-
labeled ->
54
-
higher_order ->
50
+
Type.labeled_higher_order ->
51
+
[ `Bar | `Baz of Type.triple ] ->
52
+
Type.pair ->
53
+
Type.labeled ->
54
+
Type.higher_order ->
55
55
(string -> int) ->
56
56
(int * float * char * string * char * unit) option ->
57
-
nested_pair ->
58
-
arrow ->
57
+
Type.nested_pair ->
58
+
Type.arrow ->
59
59
string ->
60
-
nested_pair array
60
+
Type.nested_pair array
61
61
```
62
62
```
63
63
type variant_e = {
64
-
```
65
-
`a : int;`
66
-
```
64
+
67
65
}
68
66
```
69
67
```
70
-
type variant =
71
-
```
72
-
```
68
+
type variant =
73
69
| A
74
-
```
75
-
```
76
70
| B of int
77
-
```
78
-
```
79
-
| C
80
-
```
81
-
foo
82
-
83
-
```
84
-
| D
85
-
```
86
-
*bar*
87
-
88
-
```
89
-
| E of variant_e
90
-
```
91
-
```
71
+
| C (** foo *)
72
+
| D (** bar *)
73
+
| E of Type.variant_e
92
74
93
75
```
94
76
```
95
77
type variant_c = {
96
-
```
97
-
`a : int;`
98
-
```
78
+
99
79
}
100
80
```
101
81
```
102
-
type _ gadt =
103
-
```
104
-
```
105
-
| A : int gadt
106
-
```
107
-
```
108
-
| B : int -> string gadt
109
-
```
110
-
```
111
-
| C : variant_c -> unit gadt
112
-
```
113
-
```
82
+
type _ gadt =
83
+
| A : int Type.gadt
84
+
| B : int -> string Type.gadt
85
+
| C : Type.variant_c -> unit Type.gadt
114
86
115
87
```
116
88
```
117
-
type degenerate_gadt =
118
-
```
119
-
```
120
-
| A : degenerate_gadt
121
-
```
122
-
```
89
+
type degenerate_gadt =
90
+
| A : Type.degenerate_gadt
123
91
124
92
```
125
93
```
126
-
type private_variant = private
127
-
```
128
-
```
94
+
type private_variant = private
129
95
| A
130
-
```
131
-
```
132
96
133
97
```
134
98
```
135
99
type record = {
136
-
```
137
-
`a : int;`
138
-
`mutable b : int;`
139
-
`c : int;`
140
-
foo
141
100
142
-
`d : int;`
143
-
*bar*
144
101
145
-
`e : 'a. 'a;`
146
-
```
102
+
(** foo *)
103
+
(** bar *)
104
+
147
105
}
148
106
```
149
107
```
150
-
type polymorphic_variant = [
151
-
```
152
-
```
108
+
type polymorphic_variant = [
153
109
| `A
154
-
```
155
-
```
156
110
| `B of int
157
-
```
158
-
```
159
111
| `C of int * unit
160
-
```
161
-
```
162
112
| `D
163
-
```
164
-
```
165
-
]
166
-
```
167
-
```
168
-
type polymorphic_variant_extension = [
169
-
```
170
-
```
171
-
| polymorphic_variant
113
+
]
172
114
```
173
115
```
116
+
type polymorphic_variant_extension = [
117
+
| Type.polymorphic_variant
174
118
| `E
175
-
```
176
-
```
177
-
]
178
-
```
179
-
```
180
-
type nested_polymorphic_variant = [
119
+
]
181
120
```
182
121
```
122
+
type nested_polymorphic_variant = [
183
123
| `A of [ `B | `C ]
184
-
```
185
-
```
186
-
]
187
-
```
188
-
```
189
-
type private_extenion = private [>
190
-
```
191
-
```
192
-
| polymorphic_variant
124
+
]
193
125
```
194
126
```
195
-
]
127
+
type private_extenion = private [>
128
+
| Type.polymorphic_variant
129
+
]
196
130
```
197
131
```
198
132
type object_ = < a : int ; b : int ; c : int >
···
201
135
module type X = sig ... end
202
136
```
203
137
```
204
-
type module_ = (module X)
138
+
type module_ = (module Type.X)
205
139
```
206
140
```
207
-
type module_substitution = (module X with type t = int and type u = unit)
141
+
type module_substitution = (module Type.X with type t = int and type u = unit)
208
142
```
209
143
```
210
144
type +'a covariant
···
219
153
type ('a, 'b) binary
220
154
```
221
155
```
222
-
type using_binary = (int, int) binary
156
+
type using_binary = (int, int) Type.binary
223
157
```
224
158
```
225
159
type 'custom name
···
240
174
type 'a upper_variant = 'a constraint 'a = [< `A | `B of int ]
241
175
```
242
176
```
243
-
type 'a named_variant = 'a constraint 'a = [< polymorphic_variant ]
177
+
type 'a named_variant = 'a constraint 'a = [< Type.polymorphic_variant ]
244
178
```
245
179
```
246
180
type 'a exact_object = 'a constraint 'a = < a : int ; b : int >
···
261
195
type extensible = ..
262
196
```
263
197
```
264
-
type extensible +=
265
-
```
266
-
```
267
-
| Extension
268
-
```
269
-
Documentation for [`Extension`](./#extension-Extension).
270
-
271
-
```
272
-
| Another_extension
273
-
```
274
-
Documentation for [`Another_extension`](./#extension-Another_extension).
275
-
276
-
```
198
+
type Type.extensible +=
199
+
| Extension (** Documentation for Extension. *)
200
+
| Another_extension (** Documentation for Another_extension. *)
277
201
278
202
```
279
203
```
280
-
type mutually =
281
-
```
282
-
```
283
-
| A of recursive
284
-
```
285
-
```
204
+
type mutually =
205
+
| A of Type.recursive
286
206
287
207
```
288
208
```
289
-
and recursive =
290
-
```
291
-
```
292
-
| B of mutually
293
-
```
294
-
```
209
+
and recursive =
210
+
| B of Type.mutually
295
211
296
212
```
297
213
```
+3
-3
odoc/test/integration/markdown.t/run.t
+3
-3
odoc/test/integration/markdown.t/run.t
···
46
46
### Section 2
47
47
48
48
```
49
-
val v : t
49
+
val v : Test.t
50
50
```
51
51
A very important value
52
52
···
84
84
type 'a t = 'a list
85
85
```
86
86
```
87
-
val head : 'a t -> 'a option
87
+
val head : 'a Test.List.t -> 'a option
88
88
```
89
89
```
90
-
val headExn : 'a t -> 'a
90
+
val headExn : 'a Test.List.t -> 'a
91
91
```
92
92
93
93
$ cat markdown/test/page.md
+85
odoc/test/markdown/adt_constructors.t/colors.mli
+85
odoc/test/markdown/adt_constructors.t/colors.mli
···
1
+
(** A module demonstrating ADT with many constructors for markdown output testing. *)
2
+
3
+
(** A color type with many variants representing different colors and color properties. *)
4
+
type color =
5
+
| Red (** Primary red color *)
6
+
| Green (** Primary green color *)
7
+
| Blue (** Primary blue color *)
8
+
| Yellow (** Yellow color (red + green) *)
9
+
| Cyan (** Cyan color (green + blue) *)
10
+
| Magenta (** Magenta color (red + blue) *)
11
+
| Orange (** Orange color *)
12
+
| Purple (** Purple color *)
13
+
| Pink (** Pink color *)
14
+
| Brown (** Brown color *)
15
+
| Black (** Black color (absence of light) *)
16
+
| White (** White color (all colors combined) *)
17
+
| Gray (** Gray color *)
18
+
| Silver (** Silver color *)
19
+
| Gold (** Gold color *)
20
+
| Maroon (** Dark red color *)
21
+
| Navy (** Dark blue color *)
22
+
| Teal (** Dark cyan color *)
23
+
| Lime (** Bright green color *)
24
+
| Olive (** Dark yellow-green color *)
25
+
| Aqua (** Light blue-green color *)
26
+
| Fuchsia (** Bright pink-purple color *)
27
+
| Indigo (** Deep blue-purple color *)
28
+
| Violet (** Blue-purple color *)
29
+
| Turquoise (** Blue-green color *)
30
+
| Coral (** Orange-pink color *)
31
+
| Salmon (** Light orange-pink color *)
32
+
| Crimson (** Deep red color *)
33
+
| Scarlet (** Bright red color *)
34
+
| Azure (** Light blue color *)
35
+
| Beige (** Light brown color *)
36
+
| Khaki (** Light brown-green color *)
37
+
| Lavender (** Light purple color *)
38
+
| Mint (** Light green color *)
39
+
| Peach (** Light orange color *)
40
+
| Plum (** Dark purple color *)
41
+
| Rust (** Orange-red color *)
42
+
| Tan (** Light brown color *)
43
+
| Ivory (** Off-white color *)
44
+
| Pearl (** Lustrous white color *)
45
+
| RGB of int * int * int (** RGB color with red, green, blue values (0-255) *)
46
+
| RGBA of int * int * int * float (** RGBA color with alpha transparency (0.0-1.0) *)
47
+
| HSL of int * int * int (** HSL color with hue (0-360), saturation, lightness (0-100) *)
48
+
| HSV of int * int * int (** HSV color with hue (0-360), saturation, value (0-100) *)
49
+
| CMYK of int * int * int * int (** CMYK color for printing (0-100 each) *)
50
+
| Hex of string (** Hexadecimal color representation (e.g., "#FF0000") *)
51
+
| Named of string (** Named color (e.g., "forestgreen", "dodgerblue") *)
52
+
| Gradient of color * color (** Gradient between two colors *)
53
+
| Pattern of color list (** Pattern of multiple colors *)
54
+
| Custom of string * (int * int * int) (** Custom color with name and RGB values *)
55
+
56
+
(** Brightness levels for colors. *)
57
+
type brightness =
58
+
| VeryDark (** Very dark variant *)
59
+
| Dark (** Dark variant *)
60
+
| Normal (** Normal brightness *)
61
+
| Light (** Light variant *)
62
+
| VeryLight (** Very light variant *)
63
+
64
+
(** Color temperature classification. *)
65
+
type temperature =
66
+
| VeryWarm (** Very warm colors (reds, oranges) *)
67
+
| Warm (** Warm colors *)
68
+
| Neutral (** Neutral temperature *)
69
+
| Cool (** Cool colors *)
70
+
| VeryCool (** Very cool colors (blues, purples) *)
71
+
72
+
(** A function to get the default RGB values for a color. *)
73
+
val to_rgb : color -> int * int * int
74
+
75
+
(** Convert a color to its brightness classification. *)
76
+
val get_brightness : color -> brightness
77
+
78
+
(** Get the temperature classification of a color. *)
79
+
val get_temperature : color -> temperature
80
+
81
+
(** Mix two colors together. *)
82
+
val mix_colors : color -> color -> color
83
+
84
+
(** Create a complementary color. *)
85
+
val complement : color -> color
+118
odoc/test/markdown/adt_constructors.t/run.t
+118
odoc/test/markdown/adt_constructors.t/run.t
···
1
+
Test the markdown output for a module with an ADT containing many constructors.
2
+
This test verifies that the markdown generator properly handles large ADTs with
3
+
various constructor types including simple variants, variants with parameters,
4
+
and proper documentation rendering.
5
+
6
+
$ ocamlc -c -bin-annot colors.mli
7
+
$ odoc compile --package colors colors.cmti
8
+
$ odoc link colors.odoc
9
+
$ odoc markdown-generate colors.odocl -o markdown
10
+
11
+
$ cat markdown/colors/Colors.md
12
+
13
+
# Module `Colors`
14
+
15
+
A module demonstrating ADT with many constructors for markdown output testing.
16
+
17
+
```
18
+
type color =
19
+
| Red (** Primary red color *)
20
+
| Green (** Primary green color *)
21
+
| Blue (** Primary blue color *)
22
+
| Yellow (** Yellow color (red + green) *)
23
+
| Cyan (** Cyan color (green + blue) *)
24
+
| Magenta (** Magenta color (red + blue) *)
25
+
| Orange (** Orange color *)
26
+
| Purple (** Purple color *)
27
+
| Pink (** Pink color *)
28
+
| Brown (** Brown color *)
29
+
| Black (** Black color (absence of light) *)
30
+
| White (** White color (all colors combined) *)
31
+
| Gray (** Gray color *)
32
+
| Silver (** Silver color *)
33
+
| Gold (** Gold color *)
34
+
| Maroon (** Dark red color *)
35
+
| Navy (** Dark blue color *)
36
+
| Teal (** Dark cyan color *)
37
+
| Lime (** Bright green color *)
38
+
| Olive (** Dark yellow-green color *)
39
+
| Aqua (** Light blue-green color *)
40
+
| Fuchsia (** Bright pink-purple color *)
41
+
| Indigo (** Deep blue-purple color *)
42
+
| Violet (** Blue-purple color *)
43
+
| Turquoise (** Blue-green color *)
44
+
| Coral (** Orange-pink color *)
45
+
| Salmon (** Light orange-pink color *)
46
+
| Crimson (** Deep red color *)
47
+
| Scarlet (** Bright red color *)
48
+
| Azure (** Light blue color *)
49
+
| Beige (** Light brown color *)
50
+
| Khaki (** Light brown-green color *)
51
+
| Lavender (** Light purple color *)
52
+
| Mint (** Light green color *)
53
+
| Peach (** Light orange color *)
54
+
| Plum (** Dark purple color *)
55
+
| Rust (** Orange-red color *)
56
+
| Tan (** Light brown color *)
57
+
| Ivory (** Off-white color *)
58
+
| Pearl (** Lustrous white color *)
59
+
| RGB of int * int * int (** RGB color with red, green, blue values (0-255) *)
60
+
| RGBA of int * int * int * float (** RGBA color with alpha transparency (0.0-1.0) *)
61
+
| HSL of int * int * int (** HSL color with hue (0-360), saturation, lightness (0-100) *)
62
+
| HSV of int * int * int (** HSV color with hue (0-360), saturation, value (0-100) *)
63
+
| CMYK of int * int * int * int (** CMYK color for printing (0-100 each) *)
64
+
| Hex of string (** Hexadecimal color representation (e.g., "#FF0000") *)
65
+
| Named of string (** Named color (e.g., "forestgreen", "dodgerblue") *)
66
+
| Gradient of Colors.color * Colors.color (** Gradient between two colors *)
67
+
| Pattern of Colors.color list (** Pattern of multiple colors *)
68
+
| Custom of string * int * int * int (** Custom color with name and RGB values *)
69
+
70
+
```
71
+
A color type with many variants representing different colors and color properties.
72
+
73
+
```
74
+
type brightness =
75
+
| VeryDark (** Very dark variant *)
76
+
| Dark (** Dark variant *)
77
+
| Normal (** Normal brightness *)
78
+
| Light (** Light variant *)
79
+
| VeryLight (** Very light variant *)
80
+
81
+
```
82
+
Brightness levels for colors.
83
+
84
+
```
85
+
type temperature =
86
+
| VeryWarm (** Very warm colors (reds, oranges) *)
87
+
| Warm (** Warm colors *)
88
+
| Neutral (** Neutral temperature *)
89
+
| Cool (** Cool colors *)
90
+
| VeryCool (** Very cool colors (blues, purples) *)
91
+
92
+
```
93
+
Color temperature classification.
94
+
95
+
```
96
+
val to_rgb : Colors.color -> int * int * int
97
+
```
98
+
A function to get the default RGB values for a color.
99
+
100
+
```
101
+
val get_brightness : Colors.color -> Colors.brightness
102
+
```
103
+
Convert a color to its brightness classification.
104
+
105
+
```
106
+
val get_temperature : Colors.color -> Colors.temperature
107
+
```
108
+
Get the temperature classification of a color.
109
+
110
+
```
111
+
val mix_colors : Colors.color -> Colors.color -> Colors.color
112
+
```
113
+
Mix two colors together.
114
+
115
+
```
116
+
val complement : Colors.color -> Colors.color
117
+
```
118
+
Create a complementary color.
+10
odoc/test/markdown/include_test.t/base.mli
+10
odoc/test/markdown/include_test.t/base.mli
+11
odoc/test/markdown/include_test.t/main.mli
+11
odoc/test/markdown/include_test.t/main.mli
···
1
+
(** Main module that includes Base *)
2
+
3
+
type base_t = int
4
+
val base_value : base_t
5
+
val base_function : base_t -> base_t
6
+
7
+
include module type of Base
8
+
(** This includes all definitions from Base module *)
9
+
10
+
val additional_function : base_t -> base_t
11
+
(** An additional function in the main module *)
+40
odoc/test/markdown/include_test.t/run.t
+40
odoc/test/markdown/include_test.t/run.t
···
1
+
Test module includes in markdown output.
2
+
3
+
$ ocamlc -c -bin-annot base.mli
4
+
$ ocamlc -c -bin-annot main.mli
5
+
$ odoc compile --package test base.cmti
6
+
$ odoc compile --package test main.cmti
7
+
$ odoc link base.odoc
8
+
$ odoc link main.odoc
9
+
$ odoc markdown-generate main.odocl -o markdown
10
+
11
+
$ cat markdown/test/Main.md
12
+
13
+
# Module `Main`
14
+
15
+
Main module that includes Base
16
+
17
+
```
18
+
type base_t = int
19
+
```
20
+
```
21
+
val base_value : Main.base_t
22
+
```
23
+
```
24
+
val base_function : Main.base_t -> Main.base_t
25
+
```
26
+
This includes all definitions from Base module
27
+
28
+
```
29
+
type t = int
30
+
```
31
+
```
32
+
val value : Main.t
33
+
```
34
+
```
35
+
val function_in_base : Main.t -> Main.t
36
+
```
37
+
```
38
+
val additional_function : Main.base_t -> Main.base_t
39
+
```
40
+
An additional function in the main module
+19
odoc/test/markdown/polymorphic_variants.t/polymorphic_variants.mli
+19
odoc/test/markdown/polymorphic_variants.t/polymorphic_variants.mli
···
1
+
(** A module demonstrating polymorphic variants for markdown output testing. *)
2
+
3
+
(** A polymorphic variant type with many constructors. *)
4
+
type color = [
5
+
| `Red (** Primary red color *)
6
+
| `Green (** Primary green color *)
7
+
| `Blue (** Primary blue color *)
8
+
| `Yellow (** Yellow color *)
9
+
| `Orange (** Orange color *)
10
+
| `Purple (** Purple color *)
11
+
| `RGB of int * int * int (** RGB values *)
12
+
| `Named of string (** Named color *)
13
+
]
14
+
15
+
(** Simple fixed polymorphic variant. *)
16
+
type status = [ `Active | `Inactive of string ]
17
+
18
+
(** Another simple polymorphic variant. *)
19
+
type simple = [ `A | `B | `C ]
+43
odoc/test/markdown/polymorphic_variants.t/run.t
+43
odoc/test/markdown/polymorphic_variants.t/run.t
···
1
+
Test polymorphic variant formatting in markdown output.
2
+
3
+
$ ocamlc -c -bin-annot polymorphic_variants.mli
4
+
$ odoc compile --package test polymorphic_variants.cmti
5
+
$ odoc link polymorphic_variants.odoc
6
+
$ odoc markdown-generate polymorphic_variants.odocl -o markdown
7
+
8
+
$ cat markdown/test/Polymorphic_variants.md
9
+
10
+
# Module `Polymorphic_variants`
11
+
12
+
A module demonstrating polymorphic variants for markdown output testing.
13
+
14
+
```
15
+
type color = [
16
+
| `Red (** Primary red color *)
17
+
| `Green (** Primary green color *)
18
+
| `Blue (** Primary blue color *)
19
+
| `Yellow (** Yellow color *)
20
+
| `Orange (** Orange color *)
21
+
| `Purple (** Purple color *)
22
+
| `RGB of int * int * int (** RGB values *)
23
+
| `Named of string (** Named color *)
24
+
]
25
+
```
26
+
A polymorphic variant type with many constructors.
27
+
28
+
```
29
+
type status = [
30
+
| `Active
31
+
| `Inactive of string
32
+
]
33
+
```
34
+
Simple fixed polymorphic variant.
35
+
36
+
```
37
+
type simple = [
38
+
| `A
39
+
| `B
40
+
| `C
41
+
]
42
+
```
43
+
Another simple polymorphic variant.
-1
odoc/test/model/semantics/dune
-1
odoc/test/model/semantics/dune
+2
-2
odoc/test/xref2/github_issue_932.t/run.t
+2
-2
odoc/test/xref2/github_issue_932.t/run.t
···
13
13
<div class="spec type extension anchored" id="extension-decl-A">
14
14
<a href="#extension-decl-A" class="anchor"></a>
15
15
<code>
16
-
<span><span class="keyword">type</span> <a href="#type-t">t</a> +=
16
+
<span><span class="keyword">type</span> <a href="#type-t">Foo.t</a> +=
17
17
</span>
18
18
--
19
19
<li id="extension-A" class="def variant extension anchored">
···
32
32
<a href="#extension-decl-C" class="anchor"></a>
33
33
<code>
34
34
<span><span class="keyword">type</span>
35
-
<a href="M/index.html#type-t">M.t</a> +=
35
+
<a href="M/index.html#type-t">Foo.M.t</a> +=
36
36
--
37
37
<li id="extension-C" class="def variant extension anchored">
38
38
<a href="#extension-C" class="anchor"></a>
+1
-1
odoc/test/xref2/initially_open.t/run.t
+1
-1
odoc/test/xref2/initially_open.t/run.t