@@ -39,6 +39,7 @@ import qualified Nirum.Constructs.TypeDeclaration as TD
39
39
import qualified Nirum.Constructs.TypeExpression as TE
40
40
import Nirum.Docs ( Block (Heading )
41
41
, filterReferences
42
+ , trimTitle
42
43
)
43
44
import Nirum.Docs.Html (render , renderInlines )
44
45
import Nirum.Package
@@ -156,10 +157,14 @@ module' :: BoundModule Docs -> Html
156
157
module' docsModule =
157
158
layout pkg depth (ModulePage docsModulePath) title $ [shamlet |
158
159
$maybe tit <- headingTitle
159
- <h1><code>#{path}</code>
160
- <p>#{tit}
160
+ <h1>
161
+ <dfn><code>#{path}</code>
162
+  — #{tit}
161
163
$nothing
162
164
<h1><code>#{path}</code>
165
+ $maybe m <- mod'
166
+ $maybe d <- docsBlock m
167
+ #{blockToHtml (trimTitle d)}
163
168
$forall (ident, decl) <- types'
164
169
<div class="#{showKind decl}" id="#{toNormalizedText ident}">
165
170
#{typeDecl docsModule ident decl}
@@ -195,100 +200,117 @@ blockToHtml b = preEscapedToMarkup $ render b
195
200
typeDecl :: BoundModule Docs -> Identifier -> TD. TypeDeclaration -> Html
196
201
typeDecl mod' ident
197
202
tc@ TD. TypeDeclaration { TD. type' = TD. Alias cname } = [shamlet |
198
- <h2><code>type</code> #{toNormalizedText ident} = #
199
- <code>#{typeExpression mod' cname}</code>
203
+ <h2>
204
+ type <dfn><code>#{toNormalizedText ident}</code></dfn> = #
205
+ <code.type>#{typeExpression mod' cname}</code>
200
206
$maybe d <- docsBlock tc
201
207
#{blockToHtml d}
202
208
|]
203
209
typeDecl mod' ident
204
210
tc@ TD. TypeDeclaration { TD. type' = TD. UnboxedType innerType } =
205
211
[shamlet |
206
- <h2><code>unboxed</code> #{toNormalizedText ident}
212
+ <h2>
213
+ unboxed
214
+ <dfn><code>#{toNormalizedText ident}</code>
207
215
(<code>#{typeExpression mod' innerType}</code>)
208
216
$maybe d <- docsBlock tc
209
217
#{blockToHtml d}
210
218
|]
211
219
typeDecl _ ident
212
220
tc@ TD. TypeDeclaration { TD. type' = TD. EnumType members } = [shamlet |
213
- <h2><code>enum</ code> #{toNormalizedText ident}
221
+ <h2>enum <dfn>< code>#{toNormalizedText ident}</code></dfn>
214
222
$maybe d <- docsBlock tc
215
223
#{blockToHtml d}
216
224
<dl class="members">
217
225
$forall decl <- DES.toList members
218
- <dt class="member-name">#{nameText $ DE.name decl}
226
+ <dt class="member-name">
227
+ <code>#{nameText $ DE.name decl}
219
228
<dd class="member-doc">
220
229
$maybe d <- docsBlock decl
221
230
#{blockToHtml d}
222
231
|]
223
232
typeDecl mod' ident
224
233
tc@ TD. TypeDeclaration { TD. type' = TD. RecordType fields } = [shamlet |
225
- <h2><code>record</ code> #{toNormalizedText ident}
234
+ <h2>record <dfn>< code>#{toNormalizedText ident}</code></dfn>
226
235
$maybe d <- docsBlock tc
227
236
#{blockToHtml d}
228
237
<dl.fields>
229
238
$forall fieldDecl@(TD.Field _ fieldType _) <- DES.toList fields
230
239
<dt>
231
- <code>#{typeExpression mod' fieldType}
232
- #{nameText $ DE.name fieldDecl}
233
- $maybe d <- docsBlock fieldDecl
234
- <dd>#{blockToHtml d}
240
+ <code.type>#{typeExpression mod' fieldType}
241
+ <var><code>#{nameText $ DE.name fieldDecl}</code>
242
+ <dd>
243
+ $maybe d <- docsBlock fieldDecl
244
+ #{blockToHtml d}
235
245
|]
236
246
typeDecl mod' ident
237
- tc@ TD. TypeDeclaration { TD. type' = TD. UnionType tags _} = [shamlet |
238
- <h2>union <code>#{toNormalizedText ident}</code>
247
+ tc@ TD. TypeDeclaration
248
+ { TD. type' = unionType@ TD. UnionType
249
+ { TD. defaultTag = defaultTag
250
+ }
251
+ } =
252
+ [shamlet |
253
+ <h2>union <dfn><code>#{toNormalizedText ident}</code></dfn>
239
254
$maybe d <- docsBlock tc
240
255
#{blockToHtml d}
241
- $forall tagDecl@(TD.Tag _ fields _) <- DES.toList tags
242
- <h3 class="tag"><code>#{nameText $ DE.name tagDecl}</code>
256
+ $forall (default_, tagDecl@(TD.Tag _ fields _)) <- tagList
257
+ <h3 .tag :default_:.default-tag>
258
+ $if default_
259
+ default tag #
260
+ $else
261
+ tag #
262
+ <dfn><code>#{nameText $ DE.name tagDecl}</code>
243
263
$maybe d <- docsBlock tagDecl
244
264
#{blockToHtml d}
245
- $forall fieldDecl@(TD.Field _ fieldType _) <- DES.toList fields
246
- <h4>
247
- <span.type>#{typeExpression mod' fieldType}
248
- <code>#{nameText $ DE.name fieldDecl}
249
- $maybe d <- docsBlock fieldDecl
250
- #{blockToHtml d}
251
- |]
265
+ <dl.fields>
266
+ $forall fieldDecl@(TD.Field _ fieldType _) <- DES.toList fields
267
+ <dt>
268
+ <code.type>#{typeExpression mod' fieldType}
269
+ <var><code>#{nameText $ DE.name fieldDecl}</code>
270
+ <dd>
271
+ $maybe d <- docsBlock fieldDecl
272
+ #{blockToHtml d}
273
+ |]
274
+ where
275
+ tagList :: [(Bool , TD. Tag )]
276
+ tagList =
277
+ [ (defaultTag == Just tag, tag)
278
+ | tag <- DES. toList (TD. tags unionType)
279
+ ]
252
280
typeDecl _ ident
253
281
TD. TypeDeclaration { TD. type' = TD. PrimitiveType {} } = [shamlet |
254
282
<h2>primitive <code>#{toNormalizedText ident}</code>
255
283
|]
256
284
typeDecl mod' ident
257
285
tc@ TD. ServiceDeclaration { TD. service = S. Service methods } =
258
286
[shamlet |
259
- <h2><code>service</ code> #{toNormalizedText ident}
287
+ <h2>service <dfn>< code>#{toNormalizedText ident}</code></dfn>
260
288
$maybe d <- docsBlock tc
261
289
#{blockToHtml d}
262
290
$forall md@(S.Method _ ps ret err _) <- DES.toList methods
263
- <h3.method>#{nameText $ DE.name md} (
264
- $forall (i, pd@(S.Parameter _ pt _)) <- enumerateParams ps
265
- $if i > 0
266
- , #
267
- <code.type>#{typeExpression mod' pt}</code> #
268
- <var>#{nameText $ DE.name pd}</var>#
269
- )
291
+ <h3.method>
292
+ $maybe retType <- ret
293
+ <span.return>
294
+ <code.type>#{typeExpression mod' retType}
295
+  
296
+ <dfn>
297
+ <code>#{nameText $ DE.name md}
298
+  
299
+ <span.parentheses>()
300
+ $maybe errType <- err
301
+ <span.error>
302
+ throws
303
+ <code.error.type>#{typeExpression mod' errType}
270
304
$maybe d <- docsBlock md
271
305
#{blockToHtml d}
272
306
<dl.parameters>
273
307
$forall paramDecl@(S.Parameter _ paramType _) <- DES.toList ps
274
308
$maybe d <- docsBlock paramDecl
275
309
<dt>
276
310
<code.type>#{typeExpression mod' paramType}
277
- <var>#{nameText $ DE.name paramDecl}</var>:
311
+ <code>< var>#{nameText $ DE.name paramDecl}</var>
278
312
<dd>#{blockToHtml d}
279
- <dl.result>
280
- $maybe retType <- ret
281
- <dt.return-label>returns:
282
- <dd.return-type><code>#{typeExpression mod' retType}</code>
283
- $maybe errType <- err
284
- <dt.raise-label>raises:
285
- <dd.raise-type><code>#{typeExpression mod' errType}</code>
286
313
|]
287
- where
288
- enumerate :: [a ] -> [(Int , a )]
289
- enumerate = zip [0 .. ]
290
- enumerateParams :: DES. DeclarationSet S. Parameter -> [(Int , S. Parameter )]
291
- enumerateParams = enumerate . DES. toList
292
314
typeDecl _ _ TD. Import {} =
293
315
error (" It shouldn't happen; please report it to Nirum's bug tracker:\n " ++
294
316
" https://github.com/spoqa/nirum/issues" )
0 commit comments