this repo has no description
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Add markdown to generator tests

Regenerate markdown reference files for the full generator test suite
to match the new unified code block and fully-qualified-paths output.

Cherry-picked from jonludlam/odoc@c19ca211f

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

+1590 -1483
+1 -1
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
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
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
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
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
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">&#45;&gt;</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
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
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
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">&#45;&gt;</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">&#45;&gt;</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
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
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
test/generators/html/Include-module-type-Inherent_Module.html
··· 21 21 <a href="#val-a" class="anchor"></a> 22 22 <code> 23 23 <span><span class="keyword">val</span> a : 24 - <a href="Include.html#type-t">t</a> 24 + <a href="Include.html#type-t">Include.t</a> 25 25 </span> 26 26 </code> 27 27 </div>
+12 -7
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
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
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
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
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
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">&#45;&gt;</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
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
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
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">&#45;&gt;</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">&#45;&gt;</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
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
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
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
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
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
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
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
test/generators/html/Module_type_subst-Local.html
··· 46 46 <span class="keyword">type</span> w 47 47 </span> 48 48 <span> = 49 - <a href="Module_type_subst-Local-module-type-local.html">local</a> 49 + <a href="Module_type_subst-Local-module-type-local.html"> 50 + Module_type_subst.Local.local 51 + </a> 50 52 </span> 51 53 </code> 52 54 </div>
+3 -1
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
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
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
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
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
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
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
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">&#45;&gt;</span> 32 - </span> <a href="#type-t">t</a> 31 + <span><a href="#type-t">Ocamlary.Aliases.E.t</a> 32 + <span class="arrow">&#45;&gt;</span> 33 + </span> <a href="#type-t">Ocamlary.Aliases.E.t</a> 33 34 </span> 34 35 </code> 35 36 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.Foo.A.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.Foo.B.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.Foo.C.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.Foo.D.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.Foo.E.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.P1.Y.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -2
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">&#45;&gt;</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">&#45;&gt;</span> 34 + </span> <a href="#type-t">Ocamlary.Aliases.P2.Z.t</a> 34 35 </span> 35 36 </code> 36 37 </div>
+3 -1
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
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
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">&#45;&gt;</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">&#45;&gt;</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
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">&#45;&gt;</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">&#45;&gt;</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
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">&#45;&gt;</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">&#45;&gt;</span> 90 101 </span> unit
+11 -5
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">&#45;&gt;</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">&#45;&gt;</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
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
test/generators/html/Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.html
··· 28 28 <code><span><span class="keyword">type</span> t</span> 29 29 <span> = 30 30 <span><span>(unit, unit)</span> 31 - <a href="Ocamlary.html#type-a_function">a_function</a> 31 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 32 32 </span> 33 33 </span> 34 34 </code>
+1 -1
test/generators/html/Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 31 31 <span> = 32 32 <a 33 33 href="Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.html#type-t" 34 - >InnerModuleA'.t 34 + >Ocamlary.CollectionModule.InnerModuleA.InnerModuleA'.t 35 35 </a> 36 36 </span> 37 37 </code>
+2 -1
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
test/generators/html/Ocamlary-Dep7-argument-1-Arg-module-type-T.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>
+1 -1
test/generators/html/Ocamlary-Dep7-argument-1-Arg.html
··· 49 49 <a href="Ocamlary-Dep7-argument-1-Arg-X.html">X</a> 50 50 </span> 51 51 <span> : 52 - <a href="Ocamlary-Dep7-argument-1-Arg-module-type-T.html">T</a> 52 + <a href="Ocamlary-Dep7-argument-1-Arg-module-type-T.html">Arg.T</a> 53 53 </span> 54 54 </code> 55 55 </div>
+1 -1
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
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
test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.html
··· 34 34 <code><span><span class="keyword">type</span> t</span> 35 35 <span> = 36 36 <span><span>(unit, unit)</span> 37 - <a href="Ocamlary.html#type-a_function">a_function</a> 37 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 38 38 </span> 39 39 </span> 40 40 </code>
+1 -1
test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 35 35 <span> = 36 36 <a 37 37 href="Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.html#type-t" 38 - >InnerModuleA'.t 38 + >Collection.InnerModuleA.InnerModuleA'.t 39 39 </a> 40 40 </span> 41 41 </code>
+1 -1
test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA.html
··· 29 29 <span> = 30 30 <a 31 31 href="Ocamlary-FunctorTypeOf-argument-1-Collection.html#type-collection" 32 - >collection 32 + >Collection.collection 33 33 </a> 34 34 </span> 35 35 </code>
+1 -1
test/generators/html/Ocamlary-FunctorTypeOf-argument-1-Collection.html
··· 62 62 <span> = 63 63 <a 64 64 href="Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.html" 65 - >InnerModuleA.InnerModuleTypeA' 65 + >Collection.InnerModuleA.InnerModuleTypeA' 66 66 </a> 67 67 </span> 68 68 </code>
+2 -1
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
test/generators/html/Ocamlary-Recollection-InnerModuleA-InnerModuleA'.html
··· 28 28 <code><span><span class="keyword">type</span> t</span> 29 29 <span> = 30 30 <span><span>(unit, unit)</span> 31 - <a href="Ocamlary.html#type-a_function">a_function</a> 31 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 32 32 </span> 33 33 </span> 34 34 </code>
+1 -1
test/generators/html/Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 29 29 <code><span><span class="keyword">type</span> t</span> 30 30 <span> = 31 31 <a href="Ocamlary-Recollection-InnerModuleA-InnerModuleA'.html#type-t"> 32 - InnerModuleA'.t 32 + InnerModuleA.InnerModuleA'.t 33 33 </a> 34 34 </span> 35 35 </code>
+1 -1
test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.html
··· 30 30 <code><span><span class="keyword">type</span> t</span> 31 31 <span> = 32 32 <span><span>(unit, unit)</span> 33 - <a href="Ocamlary.html#type-a_function">a_function</a> 33 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 34 34 </span> 35 35 </span> 36 36 </code>
+1 -1
test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 32 32 <span> = 33 33 <a 34 34 href="Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.html#type-t" 35 - >InnerModuleA'.t 35 + >C.InnerModuleA.InnerModuleA'.t 36 36 </a> 37 37 </span> 38 38 </code>
+1 -1
test/generators/html/Ocamlary-Recollection-argument-1-C-InnerModuleA.html
··· 27 27 <code><span><span class="keyword">type</span> t</span> 28 28 <span> = 29 29 <a href="Ocamlary-Recollection-argument-1-C.html#type-collection"> 30 - collection 30 + C.collection 31 31 </a> 32 32 </span> 33 33 </code>
+1 -1
test/generators/html/Ocamlary-Recollection-argument-1-C.html
··· 60 60 <span> = 61 61 <a 62 62 href="Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.html" 63 - >InnerModuleA.InnerModuleTypeA' 63 + >C.InnerModuleA.InnerModuleTypeA' 64 64 </a> 65 65 </span> 66 66 </code>
+2 -1
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
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
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
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
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
test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.html
··· 28 28 <code><span><span class="keyword">type</span> t</span> 29 29 <span> = 30 30 <span><span>(unit, unit)</span> 31 - <a href="Ocamlary.html#type-a_function">a_function</a> 31 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 32 32 </span> 33 33 </span> 34 34 </code>
+1 -1
test/generators/html/Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 30 30 <span> = 31 31 <a 32 32 href="Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.html#type-t"> 33 - InnerModuleA'.t 33 + Q.InnerModuleA.InnerModuleA'.t 34 34 </a> 35 35 </span> 36 36 </code>
+2 -1
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
test/generators/html/Ocamlary-module-type-A-Q.html
··· 57 57 <span> = 58 58 <a 59 59 href="Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.html" 60 - >InnerModuleA.InnerModuleTypeA' 60 + >Q.InnerModuleA.InnerModuleTypeA' 61 61 </a> 62 62 </span> 63 63 </code>
+2 -1
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
test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.html
··· 28 28 <code><span><span class="keyword">type</span> t</span> 29 29 <span> = 30 30 <span><span>(unit, unit)</span> 31 - <a href="Ocamlary.html#type-a_function">a_function</a> 31 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 32 32 </span> 33 33 </span> 34 34 </code>
+1 -1
test/generators/html/Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 30 30 <span> = 31 31 <a 32 32 href="Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.html#type-t"> 33 - InnerModuleA'.t 33 + Q.InnerModuleA.InnerModuleA'.t 34 34 </a> 35 35 </span> 36 36 </code>
+2 -1
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
test/generators/html/Ocamlary-module-type-B-Q.html
··· 57 57 <span> = 58 58 <a 59 59 href="Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.html" 60 - >InnerModuleA.InnerModuleTypeA' 60 + >Q.InnerModuleA.InnerModuleTypeA' 61 61 </a> 62 62 </span> 63 63 </code>
+2 -1
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
test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.html
··· 28 28 <code><span><span class="keyword">type</span> t</span> 29 29 <span> = 30 30 <span><span>(unit, unit)</span> 31 - <a href="Ocamlary.html#type-a_function">a_function</a> 31 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 32 32 </span> 33 33 </span> 34 34 </code>
+1 -1
test/generators/html/Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 30 30 <span> = 31 31 <a 32 32 href="Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.html#type-t"> 33 - InnerModuleA'.t 33 + Q.InnerModuleA.InnerModuleA'.t 34 34 </a> 35 35 </span> 36 36 </code>
+2 -1
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
test/generators/html/Ocamlary-module-type-C-Q.html
··· 57 57 <span> = 58 58 <a 59 59 href="Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.html" 60 - >InnerModuleA.InnerModuleTypeA' 60 + >Q.InnerModuleA.InnerModuleTypeA' 61 61 </a> 62 62 </span> 63 63 </code>
+4 -3
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
test/generators/html/Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.html
··· 29 29 <code><span><span class="keyword">type</span> t</span> 30 30 <span> = 31 31 <span><span>(unit, unit)</span> 32 - <a href="Ocamlary.html#type-a_function">a_function</a> 32 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 33 33 </span> 34 34 </span> 35 35 </code>
+1 -1
test/generators/html/Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 31 31 <span> = 32 32 <a 33 33 href="Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.html#type-t" 34 - >InnerModuleA'.t 34 + >InnerModuleA.InnerModuleA'.t 35 35 </a> 36 36 </span> 37 37 </code>
+2 -1
test/generators/html/Ocamlary-module-type-IncludeModuleType.html
··· 25 25 <summary class="spec include"> 26 26 <code> 27 27 <span><span class="keyword">include</span> 28 - <a href="Ocamlary-module-type-EmptySig.html">EmptySigAlias</a> 28 + <a href="Ocamlary-module-type-EmptySig.html">Ocamlary.EmptySigAlias 29 + </a> 29 30 </span> 30 31 </code> 31 32 </summary>
+1 -1
test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.html
··· 29 29 <code><span><span class="keyword">type</span> t</span> 30 30 <span> = 31 31 <span><span>(unit, unit)</span> 32 - <a href="Ocamlary.html#type-a_function">a_function</a> 32 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 33 33 </span> 34 34 </span> 35 35 </code>
+1 -1
test/generators/html/Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 30 30 <span> = 31 31 <a 32 32 href="Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.html#type-t" 33 - >InnerModuleA'.t 33 + >C.InnerModuleA.InnerModuleA'.t 34 34 </a> 35 35 </span> 36 36 </code>
+1 -1
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
test/generators/html/Ocamlary-module-type-MMM-C.html
··· 59 59 <span> = 60 60 <a 61 61 href="Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.html" 62 - >InnerModuleA.InnerModuleTypeA' 62 + >C.InnerModuleA.InnerModuleTypeA' 63 63 </a> 64 64 </span> 65 65 </code>
+2 -1
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
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
test/generators/html/Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.html
··· 31 31 <code><span><span class="keyword">type</span> t</span> 32 32 <span> = 33 33 <span><span>(unit, unit)</span> 34 - <a href="Ocamlary.html#type-a_function">a_function</a> 34 + <a href="Ocamlary.html#type-a_function">Ocamlary.a_function</a> 35 35 </span> 36 36 </span> 37 37 </code>
+1 -1
test/generators/html/Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.html
··· 33 33 <span> = 34 34 <a 35 35 href="Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.html#type-t" 36 - >InnerModuleA'.t 36 + >InnerModuleA.InnerModuleA'.t 37 37 </a> 38 38 </span> 39 39 </code>
+2 -2
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
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">&#45;&gt;</span> 43 43 </span> unit 44 44 </span>
+1 -1
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
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
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
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
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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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>&lt; f : int ; g : 1725 1747 <span>unit <span class="arrow">&#45;&gt;</span></span> unit ; 1726 - h : <a href="#type-rec_obj">rec_obj</a> &gt; 1748 + h : <a href="#type-rec_obj">Ocamlary.rec_obj</a> &gt; 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
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
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
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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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>[&lt; <span>`B of int &amp; float</span> ]</span> 238 238 </span> ] 239 239 </span> <span class="arrow">&#45;&gt;</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
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>
+3 -1
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
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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</span> 187 189 </span> 188 190 ··· 196 198 </span> <span class="arrow">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</span> 205 207 </span> 206 208 207 209 <span>string <span class="arrow">&#45;&gt;</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">&#45;&gt;</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">&#45;&gt;</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>[&gt; </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>[&lt; 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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}
+5 -5
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
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
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
test/generators/man/Functor2.3o
··· 18 18 .br 19 19 \f[CB]end\fR 20 20 .sp 21 - \f[CB]module\fR X (Y : S) (Z : S) : \f[CB]sig\fR \.\.\. \f[CB]end\fR 21 + \f[CB]module\fR X (Y : Functor2\.S) (Z : Functor2\.S) : \f[CB]sig\fR \.\.\. \f[CB]end\fR 22 22 .sp 23 23 \f[CB]module\fR \f[CB]type\fR XF = \f[CB]sig\fR 24 24 .br
+1 -1
test/generators/man/Functor_ml.Foo'.3o
··· 27 27 \fB2 Signature\fR 28 28 .in 29 29 .sp 30 - \f[CB]type\fR t = Bar\.t 30 + \f[CB]type\fR t = Functor_ml\.Bar\.t
+4 -4
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
test/generators/man/Include2.Y_include_doc.3o
··· 11 11 .SH Documentation 12 12 .sp 13 13 .nf 14 - \f[CB]type\fR t = Y\.t 14 + \f[CB]type\fR t = Include2\.Y\.t
+1 -1
test/generators/man/Include2.Y_include_synopsis.3o
··· 14 14 .SH Documentation 15 15 .sp 16 16 .nf 17 - \f[CB]type\fR t = Y\.t 17 + \f[CB]type\fR t = Include2\.Y\.t
+6 -6
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
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
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
test/generators/man/Module_type_of.3o
··· 44 44 .sp 45 45 \f[CB]module\fR X : \f[CB]sig\fR \.\.\. \f[CB]end\fR 46 46 .sp 47 - \f[CB]module\fR T : S \f[CB]with\fR \f[CB]module\fR M = X 47 + \f[CB]module\fR T : Module_type_of\.S \f[CB]with\fR \f[CB]module\fR M = Module_type_of\.X
+1 -1
test/generators/man/Module_type_of.T.3o
··· 18 18 .br 19 19 \f[CB]end\fR 20 20 .sp 21 - \f[CB]module\fR M = X 21 + \f[CB]module\fR M = Module_type_of\.X 22 22 .sp 23 23 \f[CB]module\fR N : \f[CB]module\fR \f[CB]type\fR \f[CB]of\fR \f[CB]struct\fR \f[CB]include\fR M \f[CB]end\fR
+2 -2
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
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
test/generators/man/Module_type_subst.Nested.3o
··· 30 30 \f[CB]module\fR N : \f[CB]sig\fR 31 31 .br 32 32 .ti +4 33 - \f[CB]module\fR \f[CB]type\fR t = s 33 + \f[CB]module\fR \f[CB]type\fR t = Module_type_subst\.s 34 34 .br 35 35 .ti +2 36 36 \f[CB]end\fR
+1 -1
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
test/generators/man/Nested.F.3o
··· 42 42 \fB1\.1\.2 Values\fR 43 43 .sp 44 44 .ti +2 45 - \f[CB]val\fR y : t 45 + \f[CB]val\fR y : Arg1\.t 46 46 .fi 47 47 .br 48 48 .ti +4
+1 -1
test/generators/man/Nested.X.3o
··· 34 34 \fB2 Values\fR 35 35 .in 36 36 .sp 37 - \f[CB]val\fR x : t 37 + \f[CB]val\fR x : Nested\.X\.t 38 38 .fi 39 39 .br 40 40 .ti +2
+87 -81
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
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
test/generators/man/Ocamlary.Aliases.E.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.E\.t \f[CB]\->\fR Ocamlary\.Aliases\.E\.t
+1 -1
test/generators/man/Ocamlary.Aliases.Foo.A.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.Foo\.A\.t \f[CB]\->\fR Ocamlary\.Aliases\.Foo\.A\.t
+1 -1
test/generators/man/Ocamlary.Aliases.Foo.B.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.Foo\.B\.t \f[CB]\->\fR Ocamlary\.Aliases\.Foo\.B\.t
+1 -1
test/generators/man/Ocamlary.Aliases.Foo.C.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.Foo\.C\.t \f[CB]\->\fR Ocamlary\.Aliases\.Foo\.C\.t
+1 -1
test/generators/man/Ocamlary.Aliases.Foo.D.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.Foo\.D\.t \f[CB]\->\fR Ocamlary\.Aliases\.Foo\.D\.t
+1 -1
test/generators/man/Ocamlary.Aliases.Foo.E.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.Foo\.E\.t \f[CB]\->\fR Ocamlary\.Aliases\.Foo\.E\.t
+1 -1
test/generators/man/Ocamlary.Aliases.P1.Y.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.P1\.Y\.t \f[CB]\->\fR Ocamlary\.Aliases\.P1\.Y\.t
+1 -1
test/generators/man/Ocamlary.Aliases.P2.Z.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t 15 15 .sp 16 - \f[CB]val\fR id : t \f[CB]\->\fR t 16 + \f[CB]val\fR id : Ocamlary\.Aliases\.P2\.Z\.t \f[CB]\->\fR Ocamlary\.Aliases\.P2\.Z\.t
+1 -1
test/generators/man/Ocamlary.Aliases.Std.3o
··· 19 19 .sp 20 20 \f[CB]module\fR D = Foo\.D 21 21 .sp 22 - \f[CB]module\fR E = Foo\.E 22 + \f[CB]module\fR E = Ocamlary\.Aliases\.Foo\.E
+3 -1
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
test/generators/man/Ocamlary.CanonicalTest.Base.List.3o
··· 13 13 .nf 14 14 \f[CB]type\fR 'a 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\.Base\.List\.t \f[CB]\->\fR 18 + \f[CB]'a\fR Ocamlary\.CanonicalTest\.Base\.List\.t
+6 -4
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
test/generators/man/Ocamlary.CanonicalTest.Base_Tests.C.3o
··· 13 13 .nf 14 14 \f[CB]type\fR 'a 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\.Base_Tests\.C\.t \f[CB]\->\fR 18 + \f[CB]'a\fR Ocamlary\.CanonicalTest\.Base_Tests\.C\.t
+4 -2
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
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
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
test/generators/man/Ocamlary.CollectionModule.InnerModuleA.InnerModuleA'.3o
··· 14 14 .SH Documentation 15 15 .sp 16 16 .nf 17 - \f[CB]type\fR t = (unit, unit) a_function 17 + \f[CB]type\fR t = (unit, unit) Ocamlary\.a_function 18 18 .fi 19 19 .br 20 20 .ti +2
+1 -1
test/generators/man/Ocamlary.Dep1.X.3o
··· 11 11 .SH Documentation 12 12 .sp 13 13 .nf 14 - \f[CB]module\fR Y : S 14 + \f[CB]module\fR Y : Ocamlary\.Dep1\.S
+1 -1
test/generators/man/Ocamlary.Dep2.3o
··· 25 25 \f[CB]module\fR X : \f[CB]sig\fR 26 26 .br 27 27 .ti +4 28 - \f[CB]module\fR Y : S 28 + \f[CB]module\fR Y : Arg\.S 29 29 .br 30 30 .ti +2 31 31 \f[CB]end\fR
+1 -1
test/generators/man/Ocamlary.Dep4.3o
··· 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\.Dep4\.T
+3 -3
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
test/generators/man/Ocamlary.Dep5.Z.3o
··· 13 13 .nf 14 14 \f[CB]module\fR X : Arg\.T 15 15 .sp 16 - \f[CB]module\fR Y = Dep3 16 + \f[CB]module\fR Y = Ocamlary\.Dep3
+2 -2
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
test/generators/man/Ocamlary.Dep6.X.3o
··· 11 11 .SH Documentation 12 12 .sp 13 13 .nf 14 - \f[CB]module\fR \f[CB]type\fR R = S 14 + \f[CB]module\fR \f[CB]type\fR R = Ocamlary\.Dep6\.S 15 15 .sp 16 - \f[CB]module\fR Y : R 16 + \f[CB]module\fR Y : Ocamlary\.Dep6\.X\.R
+3 -3
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
test/generators/man/Ocamlary.Dep7.M.3o
··· 13 13 .nf 14 14 \f[CB]module\fR \f[CB]type\fR R = Arg\.S 15 15 .sp 16 - \f[CB]module\fR Y : R 16 + \f[CB]module\fR Y : M\.R
+1 -1
test/generators/man/Ocamlary.ExtMod.3o
··· 13 13 .nf 14 14 \f[CB]type\fR t = \.\. 15 15 .sp 16 - \f[CB]type\fR t += 16 + \f[CB]type\fR Ocamlary\.ExtMod\.t += 17 17 .br 18 18 .ti +2 19 19 | \f[CB]Leisureforce\fR
+4 -4
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
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
test/generators/man/Ocamlary.Recollection.InnerModuleA.3o
··· 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 = InnerModuleA\.InnerModuleA'\.t 35 35 .fi 36 36 .br 37 37 .ti +4
+1 -1
test/generators/man/Ocamlary.Recollection.InnerModuleA.InnerModuleA'.3o
··· 14 14 .SH Documentation 15 15 .sp 16 16 .nf 17 - \f[CB]type\fR t = (unit, unit) a_function 17 + \f[CB]type\fR t = (unit, unit) Ocamlary\.a_function 18 18 .fi 19 19 .br 20 20 .ti +2
+1 -1
test/generators/man/Ocamlary.With3.3o
··· 11 11 .SH Documentation 12 12 .sp 13 13 .nf 14 - \f[CB]module\fR M = With2 14 + \f[CB]module\fR M = Ocamlary\.With2 15 15 .sp 16 16 \f[CB]module\fR N : M\.S
+1 -1
test/generators/man/Ocamlary.With4.3o
··· 11 11 .SH Documentation 12 12 .sp 13 13 .nf 14 - \f[CB]module\fR N : With2\.S 14 + \f[CB]module\fR N : Ocamlary\.With2\.S
+1 -1
test/generators/man/Ocamlary.With5.3o
··· 18 18 .br 19 19 \f[CB]end\fR 20 20 .sp 21 - \f[CB]module\fR N : S 21 + \f[CB]module\fR N : Ocamlary\.With5\.S
+1 -1
test/generators/man/Ocamlary.With6.3o
··· 20 20 \f[CB]module\fR \f[CB]type\fR S 21 21 .sp 22 22 .ti +4 23 - \f[CB]module\fR N : S 23 + \f[CB]module\fR N : M\.S 24 24 .br 25 25 .ti +2 26 26 \f[CB]end\fR
+5 -5
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
test/generators/man/Recent.X.3o
··· 11 11 .SH Documentation 12 12 .sp 13 13 .nf 14 - \f[CB]module\fR L := Z\.Y 14 + \f[CB]module\fR L := Recent\.Z\.Y 15 15 .sp 16 16 \f[CB]type\fR t = int L\.X\.t 17 17 .sp 18 18 \f[CB]type\fR u := int 19 19 .sp 20 - \f[CB]type\fR v = u L\.X\.t 20 + \f[CB]type\fR v = Recent\.X\.u L\.X\.t
+1 -1
test/generators/man/Recent_impl.3o
··· 47 47 .br 48 48 \f[CB]end\fR 49 49 .sp 50 - \f[CB]module\fR B' = Foo\.B 50 + \f[CB]module\fR B' = Recent_impl\.Foo\.B
+1 -1
test/generators/man/Toplevel_comments.3o
··· 85 85 Doc of M'', part 1\. 86 86 .nf 87 87 .sp 88 - \f[CB]module\fR Alias : T 88 + \f[CB]module\fR Alias : Toplevel_comments\.T 89 89 .fi 90 90 .br 91 91 .ti +2
+23 -23
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
test/generators/markdown/Functor-F1.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module Arg : S 8 + module Arg : Functor.S 9 9 ``` 10 10 11 11 ## Signature
+1 -1
test/generators/markdown/Functor-F2.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module Arg : S 8 + module Arg : Functor.S 9 9 ``` 10 10 11 11 ## Signature
+1 -1
test/generators/markdown/Functor-F3.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module Arg : S 8 + module Arg : Functor.S 9 9 ``` 10 10 11 11 ## Signature
+1 -1
test/generators/markdown/Functor-F4.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module Arg : S 8 + module Arg : Functor.S 9 9 ``` 10 10 11 11 ## Signature
+1 -1
test/generators/markdown/Functor-module-type-S1.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module _ : S 8 + module _ : Functor.S 9 9 ``` 10 10 11 11 ## Signature
+6 -6
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
test/generators/markdown/Functor2-X.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module Y : S 8 + module Y : Functor2.S 9 9 ``` 10 10 ``` 11 - module Z : S 11 + module Z : Functor2.S 12 12 ``` 13 13 14 14 ## Signature
+2 -2
test/generators/markdown/Functor2-module-type-XF.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 - module Y : S 8 + module Y : Functor2.S 9 9 ``` 10 10 ``` 11 - module Z : S 11 + module Z : Functor2.S 12 12 ``` 13 13 14 14 ## Signature
+5 -2
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
test/generators/markdown/Functor_ml-Foo'.md
··· 11 11 ## Signature 12 12 13 13 ``` 14 - type t = Bar.t 14 + type t = Functor_ml.Bar.t 15 15 ```
+1 -1
test/generators/markdown/Include-module-type-Dorminant_Module.md
··· 2 2 # Module type `Include.Dorminant_Module` 3 3 4 4 ``` 5 - val a : u 5 + val a : Include.u 6 6 ```
+1 -1
test/generators/markdown/Include-module-type-Inherent_Module.md
··· 2 2 # Module type `Include.Inherent_Module` 3 3 4 4 ``` 5 - val a : t 5 + val a : Include.t 6 6 ```
+1 -1
test/generators/markdown/Include.md
··· 32 32 module type Dorminant_Module = sig ... end 33 33 ``` 34 34 ``` 35 - val a : u 35 + val a : Include.u 36 36 ```
+1 -1
test/generators/markdown/Include2-Y_include_doc.md
··· 4 4 Doc attached to `include Y`. `Y`'s top-comment shouldn't appear here. 5 5 6 6 ``` 7 - type t = Y.t 7 + type t = Include2.Y.t 8 8 ```
+1 -1
test/generators/markdown/Include2-Y_include_synopsis.md
··· 4 4 The `include Y` below should have the synopsis from `Y`'s top-comment attached to it. 5 5 6 6 ``` 7 - type t = Y.t 7 + type t = Include2.Y.t 8 8 ```
+8 -22
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
test/generators/markdown/Module-module-type-S7.md
··· 14 14 type ('a, 'b) w 15 15 ``` 16 16 ``` 17 - module M = M' 17 + module M = Module.M' 18 18 ```
+8 -8
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
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
test/generators/markdown/Module_type_of-T.md
··· 5 5 module type T = sig ... end 6 6 ``` 7 7 ``` 8 - module M = X 8 + module M = Module_type_of.X 9 9 ``` 10 10 ``` 11 11 module N : module type of struct include M end
+1 -1
test/generators/markdown/Module_type_of.md
··· 8 8 module X : sig ... end 9 9 ``` 10 10 ``` 11 - module T : S with module M = X 11 + module T : Module_type_of.S with module M = Module_type_of.X 12 12 ```
+1 -1
test/generators/markdown/Module_type_subst-Basic-module-type-a.md
··· 2 2 # Module type `Basic.a` 3 3 4 4 ``` 5 - module type b = s 5 + module type b = Module_type_subst.s 6 6 ``` 7 7 ``` 8 8 module M : b
+1 -1
test/generators/markdown/Module_type_subst-Basic-module-type-c.md
··· 2 2 # Module type `Basic.c` 3 3 4 4 ``` 5 - module M : s 5 + module M : Module_type_subst.s 6 6 ```
+1 -1
test/generators/markdown/Module_type_subst-Basic-module-type-with_.md
··· 2 2 # Module type `Basic.with_` 3 3 4 4 ``` 5 - module type T = s 5 + module type T = Module_type_subst.s 6 6 ```
+6 -3
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
test/generators/markdown/Module_type_subst-Local-module-type-local.md
··· 2 2 # Module type `Local.local` 3 3 4 4 ``` 5 - type t = local 5 + type t = Module_type_subst.Local.local 6 6 ```
+1 -1
test/generators/markdown/Module_type_subst-Local.md
··· 8 8 module type local := sig ... end 9 9 ``` 10 10 ``` 11 - module type w = local 11 + module type w = Module_type_subst.Local.local 12 12 ``` 13 13 ``` 14 14 module type s = sig ... end
+1 -1
test/generators/markdown/Module_type_subst-Nested-module-type-with_-N.md
··· 2 2 # Module `with_.N` 3 3 4 4 ``` 5 - module type t = s 5 + module type t = Module_type_subst.s 6 6 ```
+4 -2
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
test/generators/markdown/Module_type_subst-Structural-module-type-u-module-type-a-module-type-b-module-type-c.md
··· 2 2 # Module type `b.c` 3 3 4 4 ``` 5 - type t = 6 - ``` 7 - ``` 5 + type t = 8 6 | A of t 9 - ``` 10 - ``` 11 7 12 8 ```
+1 -5
test/generators/markdown/Module_type_subst-Structural-module-type-w-module-type-a-module-type-b-module-type-c.md
··· 2 2 # Module type `b.c` 3 3 4 4 ``` 5 - type t = 6 - ``` 7 - ``` 5 + type t = 8 6 | A of t 9 - ``` 10 - ``` 11 7 12 8 ```
+1 -1
test/generators/markdown/Module_type_subst-Structural.md
··· 5 5 module type u = sig ... end 6 6 ``` 7 7 ``` 8 - module type w = u with module type a = sig ... end 8 + module type w = Module_type_subst.Structural.u with module type a = sig ... end 9 9 ```
+1 -1
test/generators/markdown/Nested-F-argument-1-Arg1.md
··· 13 13 ## Values 14 14 15 15 ``` 16 - val y : t 16 + val y : Arg1.t 17 17 ``` 18 18 The value of y.
+1 -1
test/generators/markdown/Nested-F.md
··· 9 9 ## Parameters 10 10 11 11 ``` 12 - module Arg1 : Y 12 + module Arg1 : Nested.Y 13 13 ``` 14 14 ``` 15 15 module Arg2 : sig ... end
+1 -1
test/generators/markdown/Nested-X.md
··· 17 17 ## Values 18 18 19 19 ``` 20 - val x : t 20 + val x : Nested.X.t 21 21 ``` 22 22 The value of x.
+1 -1
test/generators/markdown/Nested.md
··· 23 23 ## Functor 24 24 25 25 ``` 26 - module F (Arg1 : Y) (Arg2 : sig ... end) : sig ... end 26 + module F (Arg1 : Nested.Y) (Arg2 : sig ... end) : sig ... end 27 27 ``` 28 28 This is a functor F. 29 29
+1 -1
test/generators/markdown/Ocamlary-Aliases-E.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.E.t -> Ocamlary.Aliases.E.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-Foo-A.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.Foo.A.t -> Ocamlary.Aliases.Foo.A.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-Foo-B.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.Foo.B.t -> Ocamlary.Aliases.Foo.B.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-Foo-C.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.Foo.C.t -> Ocamlary.Aliases.Foo.C.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-Foo-D.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.Foo.D.t -> Ocamlary.Aliases.Foo.D.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-Foo-E.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.Foo.E.t -> Ocamlary.Aliases.Foo.E.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-P1-Y.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.P1.Y.t -> Ocamlary.Aliases.P1.Y.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-P2-Z.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - val id : t -> t 8 + val id : Ocamlary.Aliases.P2.Z.t -> Ocamlary.Aliases.P2.Z.t 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Aliases-Std.md
··· 14 14 module D = Foo.D 15 15 ``` 16 16 ``` 17 - module E = Foo.E 17 + module E = Ocamlary.Aliases.Foo.E 18 18 ```
+7 -7
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
test/generators/markdown/Ocamlary-CanonicalTest-Base-List.md
··· 5 5 type 'a t 6 6 ``` 7 7 ``` 8 - val id : 'a t -> 'a t 8 + val id : 9 + 'a Ocamlary.CanonicalTest.Base.List.t -> 10 + 'a Ocamlary.CanonicalTest.Base.List.t 9 11 ```
+3 -1
test/generators/markdown/Ocamlary-CanonicalTest-Base_Tests-C.md
··· 5 5 type 'a t 6 6 ``` 7 7 ``` 8 - val id : 'a t -> 'a t 8 + val id : 9 + 'a Ocamlary.CanonicalTest.Base_Tests.C.t -> 10 + 'a Ocamlary.CanonicalTest.Base_Tests.C.t 9 11 ```
+6 -4
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
test/generators/markdown/Ocamlary-CanonicalTest-List_modif.md
··· 2 2 # Module `CanonicalTest.List_modif` 3 3 4 4 ``` 5 - type 'c t = 'c Base.List.t 5 + type 'c t = 'c Ocamlary.CanonicalTest.Base.List.t 6 6 ``` 7 7 ``` 8 - val id : 'a t -> 'a t 8 + val id : 9 + 'a Ocamlary.CanonicalTest.List_modif.t -> 10 + 'a Ocamlary.CanonicalTest.List_modif.t 9 11 ```
+3 -1
test/generators/markdown/Ocamlary-CanonicalTest.md
··· 8 8 module Base_Tests : sig ... end 9 9 ``` 10 10 ``` 11 - module List_modif : module type of Base.List with type 'c t = 'c Base.List.t 11 + module List_modif : 12 + module type of Base.List 13 + with type 'c t = 'c Ocamlary.CanonicalTest.Base.List.t 12 14 ```
+1 -1
test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = Ocamlary.CollectionModule.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-CollectionModule-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = Ocamlary.CollectionModule.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+2 -1
test/generators/markdown/Ocamlary-CollectionModule.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = 21 + Ocamlary.CollectionModule.InnerModuleA.InnerModuleTypeA' 21 22 ``` 22 23 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-Dep1-X.md
··· 2 2 # Module `Dep1.X` 3 3 4 4 ``` 5 - module Y : S 5 + module Y : Ocamlary.Dep1.S 6 6 ```
+1 -1
test/generators/markdown/Ocamlary-Dep2-argument-1-Arg-X.md
··· 2 2 # Module `Arg.X` 3 3 4 4 ``` 5 - module Y : S 5 + module Y : Arg.S 6 6 ```
+1 -1
test/generators/markdown/Ocamlary-Dep4-module-type-S.md
··· 2 2 # Module type `Dep4.S` 3 3 4 4 ``` 5 - module X : T 5 + module X : Ocamlary.Dep4.T 6 6 ``` 7 7 ``` 8 8 module Y : sig ... end
+1 -1
test/generators/markdown/Ocamlary-Dep4.md
··· 8 8 module type S = sig ... end 9 9 ``` 10 10 ``` 11 - module X : T 11 + module X : Ocamlary.Dep4.T 12 12 ```
+1 -1
test/generators/markdown/Ocamlary-Dep5-Z.md
··· 5 5 module X : Arg.T 6 6 ``` 7 7 ``` 8 - module Y = Dep3 8 + module Y = Ocamlary.Dep3 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Dep5-argument-1-Arg-module-type-S.md
··· 2 2 # Module type `Arg.S` 3 3 4 4 ``` 5 - module X : T 5 + module X : Arg.T 6 6 ``` 7 7 ``` 8 8 module Y : sig ... end
+1 -1
test/generators/markdown/Ocamlary-Dep5-argument-1-Arg.md
··· 8 8 module type S = sig ... end 9 9 ``` 10 10 ``` 11 - module X : T 11 + module X : Arg.T 12 12 ```
+1 -1
test/generators/markdown/Ocamlary-Dep5.md
··· 11 11 ## Signature 12 12 13 13 ``` 14 - module Z : Arg.S with module Y = Dep3 14 + module Z : Arg.S with module Y = Ocamlary.Dep3 15 15 ```
+2 -2
test/generators/markdown/Ocamlary-Dep6-X.md
··· 2 2 # Module `Dep6.X` 3 3 4 4 ``` 5 - module type R = S 5 + module type R = Ocamlary.Dep6.S 6 6 ``` 7 7 ``` 8 - module Y : R 8 + module Y : Ocamlary.Dep6.X.R 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Dep6-module-type-T.md
··· 2 2 # Module type `Dep6.T` 3 3 4 4 ``` 5 - module type R = S 5 + module type R = Ocamlary.Dep6.S 6 6 ``` 7 7 ``` 8 8 module Y : R
+1 -1
test/generators/markdown/Ocamlary-Dep6.md
··· 8 8 module type T = sig ... end 9 9 ``` 10 10 ``` 11 - module X : T 11 + module X : Ocamlary.Dep6.T 12 12 ```
+1 -1
test/generators/markdown/Ocamlary-Dep7-M.md
··· 5 5 module type R = Arg.S 6 6 ``` 7 7 ``` 8 - module Y : R 8 + module Y : M.R 9 9 ```
+2 -2
test/generators/markdown/Ocamlary-Dep7-argument-1-Arg-X.md
··· 2 2 # Module `Arg.X` 3 3 4 4 ``` 5 - module type R = S 5 + module type R = Arg.S 6 6 ``` 7 7 ``` 8 - module Y : R 8 + module Y : Arg.X.R 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-Dep7-argument-1-Arg-module-type-T.md
··· 2 2 # Module type `Arg.T` 3 3 4 4 ``` 5 - module type R = S 5 + module type R = Arg.S 6 6 ``` 7 7 ``` 8 8 module Y : R
+1 -1
test/generators/markdown/Ocamlary-Dep7-argument-1-Arg.md
··· 8 8 module type T = sig ... end 9 9 ``` 10 10 ``` 11 - module X : T 11 + module X : Arg.T 12 12 ```
+1 -5
test/generators/markdown/Ocamlary-ExtMod.md
··· 5 5 type t = .. 6 6 ``` 7 7 ``` 8 - type t += 9 - ``` 10 - ``` 8 + type Ocamlary.ExtMod.t += 11 9 | Leisureforce 12 - ``` 13 - ``` 14 10 15 11 ```
+1 -1
test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = Collection.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = Collection.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+1 -1
test/generators/markdown/Ocamlary-FunctorTypeOf-argument-1-Collection.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = Collection.InnerModuleA.InnerModuleTypeA' 21 21 ``` 22 22 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-FunctorTypeOf.md
··· 7 7 ## Parameters 8 8 9 9 ``` 10 - module Collection : module type of CollectionModule 10 + module Collection : module type of Ocamlary.CollectionModule 11 11 ``` 12 12 13 13 ## Signature
+1 -1
test/generators/markdown/Ocamlary-Recollection-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-Recollection-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = C.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-Recollection-argument-1-C-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = C.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+1 -1
test/generators/markdown/Ocamlary-Recollection-argument-1-C.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = C.InnerModuleA.InnerModuleTypeA' 21 21 ``` 22 22 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-Recollection.md
··· 7 7 ## Parameters 8 8 9 9 ``` 10 - module C : COLLECTION 10 + module C : Ocamlary.COLLECTION 11 11 ``` 12 12 13 13 ## Signature
+1 -1
test/generators/markdown/Ocamlary-With3.md
··· 2 2 # Module `Ocamlary.With3` 3 3 4 4 ``` 5 - module M = With2 5 + module M = Ocamlary.With2 6 6 ``` 7 7 ``` 8 8 module N : M.S
+1 -1
test/generators/markdown/Ocamlary-With4.md
··· 2 2 # Module `Ocamlary.With4` 3 3 4 4 ``` 5 - module N : With2.S 5 + module N : Ocamlary.With2.S 6 6 ```
+1 -1
test/generators/markdown/Ocamlary-With5.md
··· 5 5 module type S = sig ... end 6 6 ``` 7 7 ``` 8 - module N : S 8 + module N : Ocamlary.With5.S 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-With6-module-type-T-M.md
··· 5 5 module type S 6 6 ``` 7 7 ``` 8 - module N : S 8 + module N : M.S 9 9 ```
+1 -1
test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = Q.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-A-Q-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = Q.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+1 -1
test/generators/markdown/Ocamlary-module-type-A-Q.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = Q.InnerModuleA.InnerModuleTypeA' 21 21 ``` 22 22 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-module-type-A.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - module Q : COLLECTION 8 + module Q : Ocamlary.COLLECTION 9 9 ``` 10 10 This comment is for `CollectionModule`.
+1 -1
test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = Q.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-B-Q-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = Q.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+1 -1
test/generators/markdown/Ocamlary-module-type-B-Q.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = Q.InnerModuleA.InnerModuleTypeA' 21 21 ``` 22 22 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-module-type-B.md
··· 5 5 type t 6 6 ``` 7 7 ``` 8 - module Q : COLLECTION 8 + module Q : Ocamlary.COLLECTION 9 9 ``` 10 10 This comment is for `CollectionModule`.
+1 -1
test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = Q.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-C-Q-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = Q.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+1 -1
test/generators/markdown/Ocamlary-module-type-C-Q.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = Q.InnerModuleA.InnerModuleTypeA' 21 21 ``` 22 22 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-module-type-C.md
··· 9 9 type t 10 10 ``` 11 11 ``` 12 - module Q : COLLECTION 12 + module Q : Ocamlary.COLLECTION 13 13 ``` 14 14 This comment is for `CollectionModule`.
+1 -1
test/generators/markdown/Ocamlary-module-type-COLLECTION-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-COLLECTION-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = C.InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-MMM-C-InnerModuleA.md
··· 4 4 This comment is for `InnerModuleA`. 5 5 6 6 ``` 7 - type t = collection 7 + type t = C.collection 8 8 ``` 9 9 This comment is for `t`. 10 10
+1 -1
test/generators/markdown/Ocamlary-module-type-MMM-C.md
··· 17 17 This comment is for `InnerModuleA`. 18 18 19 19 ``` 20 - module type InnerModuleTypeA = InnerModuleA.InnerModuleTypeA' 20 + module type InnerModuleTypeA = C.InnerModuleA.InnerModuleTypeA' 21 21 ``` 22 22 This comment is for `InnerModuleTypeA`.
+1 -1
test/generators/markdown/Ocamlary-module-type-MMM.md
··· 2 2 # Module type `Ocamlary.MMM` 3 3 4 4 ``` 5 - module C : COLLECTION 5 + module C : Ocamlary.COLLECTION 6 6 ``` 7 7 This comment is for `CollectionModule`.
+1 -1
test/generators/markdown/Ocamlary-module-type-RECOLLECTION.md
··· 2 2 # Module type `Ocamlary.RECOLLECTION` 3 3 4 4 ``` 5 - module C = Recollection(CollectionModule) 5 + module C = Ocamlary.Recollection(Ocamlary.CollectionModule) 6 6 ```
+1 -1
test/generators/markdown/Ocamlary-module-type-RecollectionModule-InnerModuleA-InnerModuleA'.md
··· 4 4 This comment is for `InnerModuleA'`. 5 5 6 6 ``` 7 - type t = (unit, unit) a_function 7 + type t = (unit, unit) Ocamlary.a_function 8 8 ``` 9 9 This comment is for `t`.
+1 -1
test/generators/markdown/Ocamlary-module-type-RecollectionModule-InnerModuleA-module-type-InnerModuleTypeA'.md
··· 4 4 This comment is for `InnerModuleTypeA'`. 5 5 6 6 ``` 7 - type t = InnerModuleA'.t 7 + type t = InnerModuleA.InnerModuleA'.t 8 8 ``` 9 9 This comment is for `t`.
+2 -2
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
test/generators/markdown/Ocamlary-module-type-TypeExt.md
··· 5 5 type t = .. 6 6 ``` 7 7 ``` 8 - type t += 9 - ``` 10 - ``` 8 + type t += 11 9 | C 12 - ``` 13 - ``` 14 10 15 11 ``` 16 12 ```
+2 -6
test/generators/markdown/Ocamlary-module-type-TypeExtPruned.md
··· 2 2 # Module type `Ocamlary.TypeExtPruned` 3 3 4 4 ``` 5 - type new_t += 6 - ``` 7 - ``` 5 + type Ocamlary.new_t += 8 6 | C 9 - ``` 10 - ``` 11 7 12 8 ``` 13 9 ``` 14 - val f : new_t -> unit 10 + val f : Ocamlary.new_t -> unit 15 11 ```
+1 -1
test/generators/markdown/Ocamlary-module-type-With11.md
··· 2 2 # Module type `Ocamlary.With11` 3 3 4 4 ``` 5 - module M = With9 5 + module M = Ocamlary.With9 6 6 ``` 7 7 ``` 8 8 module N : M.S with type t = int
+1 -1
test/generators/markdown/Ocamlary-module-type-With8-M-N.md
··· 2 2 # Module `M.N` 3 3 4 4 ``` 5 - type t = With5.N.t 5 + type t = Ocamlary.With5.N.t 6 6 ```
+4 -2
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
test/generators/markdown/Ocamlary-module-type-With8.md
··· 2 2 # Module type `Ocamlary.With8` 3 3 4 4 ``` 5 - module M : module type of struct include With5 end with type N.t = With5.N.t 5 + module M : 6 + module type of struct include Ocamlary.With5 end 7 + with type N.t = Ocamlary.With5.N.t 6 8 ```
+102 -272
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
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
test/generators/markdown/Recent-module-type-PolyS.md
··· 2 2 # Module type `Recent.PolyS` 3 3 4 4 ``` 5 + <<<<<<< HEAD 5 6 type t = [ 6 7 ``` 7 8 ``` ··· 12 13 ``` 13 14 ``` 14 15 ] 16 + ======= 17 + type t = [ 18 + | `A 19 + | `B 20 + ] 21 + >>>>>>> baf34b7f4 (Add markdown to generator tests) 15 22 ```
+4
test/generators/markdown/Recent-module-type-S1.md
··· 5 5 ## Parameters 6 6 7 7 ``` 8 + <<<<<<< HEAD 8 9 module _ : S 10 + ======= 11 + module _ : Recent.S 12 + >>>>>>> baf34b7f4 (Add markdown to generator tests) 9 13 ``` 10 14 11 15 ## Signature
+45
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
test/generators/markdown/Recent_impl-B.md
··· 2 2 # Module `Recent_impl.B` 3 3 4 4 ``` 5 - type t = 6 - ``` 7 - ``` 5 + type t = 8 6 | B 9 - ``` 10 - ``` 11 7 12 8 ```
+1 -5
test/generators/markdown/Recent_impl-Foo-A.md
··· 2 2 # Module `Foo.A` 3 3 4 4 ``` 5 - type t = 6 - ``` 7 - ``` 5 + type t = 8 6 | A 9 - ``` 10 - ``` 11 7 12 8 ```
+1 -5
test/generators/markdown/Recent_impl-Foo-B.md
··· 2 2 # Module `Foo.B` 3 3 4 4 ``` 5 - type t = 6 - ``` 7 - ``` 5 + type t = 8 6 | B 9 - ``` 10 - ``` 11 7 12 8 ```
+1 -1
test/generators/markdown/Recent_impl.md
··· 14 14 module type S = sig ... end 15 15 ``` 16 16 ``` 17 - module B' = Foo.B 17 + module B' = Recent_impl.Foo.B 18 18 ```
+1 -1
test/generators/markdown/Toplevel_comments.md
··· 44 44 Doc of `M''`, part 1\. 45 45 46 46 ``` 47 - module Alias : T 47 + module Alias : Toplevel_comments.T 48 48 ``` 49 49 Doc of `Alias`. 50 50
+46 -130
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
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
+10
test/markdown/include_test.t/base.mli
··· 1 + (** Base module with some types and functions *) 2 + 3 + type t = int 4 + (** A simple type *) 5 + 6 + val value : t 7 + (** A value of type t *) 8 + 9 + val function_in_base : t -> t 10 + (** A function in the base module *)
+11
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
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
+3 -3
test/xref2/canonical_hidden_module.t/run.t
··· 153 153 <div class="spec type anchored" id="type-a"> 154 154 <a href="#type-a" class="anchor"></a> 155 155 <code><span><span class="keyword">type</span> a</span> 156 - <span> = <a href="A/index.html#type-t">A.t</a></span> 156 + <span> = <a href="A/index.html#type-t">Test.A.t</a></span> 157 157 </code> 158 158 </div> 159 159 <div class="spec-doc"> ··· 177 177 <div class="spec type anchored" id="type-c"> 178 178 <a href="#type-c" class="anchor"></a> 179 179 <code><span><span class="keyword">type</span> c</span> 180 - <span> = <a href="C/index.html#type-t">C.t</a></span> 180 + <span> = <a href="C/index.html#type-t">Test.C.t</a></span> 181 181 </code> 182 182 </div> 183 183 <div class="spec-doc"> ··· 188 188 <div class="spec type anchored" id="type-d"> 189 189 <a href="#type-d" class="anchor"></a> 190 190 <code><span><span class="keyword">type</span> d</span> 191 - <span> = <a href="D/index.html#type-t">D.t</a></span> 191 + <span> = <a href="D/index.html#type-t">Test.D.t</a></span> 192 192 </code> 193 193 </div> 194 194 <div class="spec-doc">
+2 -2
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
test/xref2/initially_open.t/run.t
··· 33 33 $ odoc link -I . other.odoc 34 34 $ odoc html-generate -o . other.odocl --indent 35 35 $ grep To_open x/Other/index.html 36 - <span> = <a href="../To_open/index.html#type-t">t</a></span> 36 + <span> = <a href="../To_open/index.html#type-t">To_open.t</a></span> 37 37