4.1 Getting Started with Documentation

► |  | Scribble: The Racket Documentation Tool

1 | Getting Started
2 | @ Syntax
3 | High-Level Scribble API
4 | Scribbling Documentation
5 | Literate Programming
6 | Low-Level Scribble API
7 | Running scribble
| Index

▼ | 4 | Scribbling Documentation

4.1 | Getting Started with Documentation
4.2 | Manual Forms
4.3 | Racket
4.4 | Evaluation and Examples
4.5 | In-Source Documentation
4.6 | BNF Grammars
4.7 | Compatibility Libraries

► | 4.1 | Getting Started with Documentation

4.1.1 | Setting Up Library Documentation
4.1.2 | Racket Typesetting and Hyperlinks
4.1.3 | Section Hyperlinks
4.1.4 | Defining Racket Bindings
4.1.5 | Showing Racket Examples
4.1.6 | Multi-Page Sections

On this page:

4.1.1`` Setting Up Library Documentation
4.1.2`` Racket Typesetting and Hyperlinks
4.1.3`` Section Hyperlinks
4.1.4`` Defining Racket Bindings
4.1.5`` Showing Racket Examples
4.1.6`` Multi-Page Sections

top ← prev up next →

#### 4.1`` Getting Started with Documentation

Although the scribble command-line utility generates output from a Scribble document, documentation of Racket libraries is normally built by raco setup. This chapter emphasizes the raco setup approach, which more automatically supports links across documents.

> > > See Getting Started for information on using the scribble command-line utility.

##### 4.1.1`` Setting Up Library Documentation

To document a collection, including a collection implemented by a package:

- Create a file in your collection with the file extension ".scrbl". Beware that the file name you choose will determine the output directory’s name, and the directory name must be unique across all installed documents. The remainder of these instructions assume that the file is called "manual.scrbl" (but pick a more specific name in practice).

- Start "manual.scrbl" like this:

  > #lang scribble/manual
  > @title{My Library}
  > Welcome to my documentation: @racket[(list 'testing 1 2 3)].

  The first line starts the file in “text” mode and selects the Racket manual output format. It also introduces bindings like title and racket for writing Racket documentation.

- Add the following entry to your collection’s "info.rkt":

  > (define scribblings '(("manual.scrbl" ())))

  The () above is a list of options. When your document gets large enough that you want it split into multiple pages, add the 'multi-page option (omitting the quote, since the whole right-hand side of the definition is already quoted).

  If you do not already have an "info.rkt" module, here’s a suitable complete module:

  > #lang info
  > (define scribblings '(("manual.scrbl" ())))

- Run raco setup to build your documentation. For a collection, optionally supply -l followed by the collection name to limit the build process to that collection.

- For a collection that is installed as user-specific (e.g., the user package scope), the generated documentation is "doc/manual/index.html" within the collection directory. If the collection is installation-wide, however, then the documentation is generated as "manual/index.html" in the installation’s "doc" directory.

##### 4.1.2`` Racket Typesetting and Hyperlinks

In the document source at the start of this chapter (Setting Up Library Documentation), the Racket expression (list 'testing 1 2 3) is typeset properly, but the list identifier is not hyperlinked to the usual definition. To cause list to be hyperlinked, add a require form like this:

> @(require (for-label racket))

This require with for-label declaration introduces a document-time binding for each export of the racket module. When the document is built, the racket form detects the binding for list, and so it generates a reference to the specification of list. The setup process detects the reference, and it finds the matching specification in the existing documentation, and ultimately directs the hyperlink to that specification.

Hyperlinks based on for-label and racket are the preferred mechanism for linking to information outside of a single document. Such links require no information about where and how a binding is documented elsewhere:

> #lang scribble/manual
> @(require (for-label racket))
> @title{My Library}
> See also @racket[list].

The racket form typesets a Racket expression for inline text, so it ignores the source formatting of the expression. The racketblock form, in contrast, typesets inset Racket code, and it preserves the expression’s formatting from the document source.

> #lang scribble/manual
> @(require (for-label racket))
> @title{My Library}
> Some example Racket code:
> @racketblock[
> (define (nobody-understands-me what)
> (list "When I think of all the"
> what
> "I've tried so hard to explain!"))
> (nobody-understands-me "glorble snop")
> ]

##### 4.1.3`` Section Hyperlinks

A section declaration in a document can include a #:tag argument that declares a hyperlink-target tag. The secref function generates a hyperlink, using the section name as the text of the hyperlink. Use seclink to create a hyperlink with text other than the section title.

The following example illustrates section hyperlinks:

> #lang scribble/manual
> @(require (for-label racket))
> @title{My Library}
> Welcome to my documentation: @racket[(list 'testing 1 2 3)].
> @table-of-contents[]
> @section[#:tag "chickens"]{Philadelphia Chickens}
> Dancing tonight!
> @section{Reprise}
> See @secref{chickens}.

Since the page is so short, the hyperlinks in the above example are more effective if you change the "info.rkt" file to add the 'multi-file flag:

> (define scribblings '(("manual.scrbl" (multi-page))))

A section can have a tag prefix that applies to all tags as seen from outside the section. Such a prefix is automatically given to each top-level document as processed by raco setup. Thus, referencing a section tag in a different document requires using a prefix, which is based on the target document’s main source file. The following example links to a section in the Racket reference manual:

> #lang scribble/manual
> @(require (for-label racket))
> @(define ref-src
> '(lib "scribblings/reference/reference.scrbl"))
> @title{My Library}
> See also @italic{@secref[#:doc ref-src]{pairs}}.

As mentioned in Racket Typesetting and Hyperlinks, however, cross-document references based on (require (for-label ....)) and racket are usually better than cross-document references using secref.

##### 4.1.4`` Defining Racket Bindings

Use defproc to document a procedure, defform to document a syntactic form, defstruct to document a structure type, etc. These forms provide consistent formatting of definitions, and they declare hyperlink targets for racket-based hyperlinks.

To document a my-helper procedure that is exported by "helper.rkt" in the "my-lib" collection that contains "manual.scrbl":

- Use (require (for-label "helper.rkt")) to import the binding information about the bindings of "helper.rkt" for use when typesetting identifiers. A relative reference "helper.rkt" works since it is relative to the documentation source.

- Add a @defmodule[my-lib/helper] declaration, which specifies the library that is being documented within the section. The defmodule form needs an absolute module name mylib/helper, instead of a relative reference "helper.rkt", since the module path given to defmodule appears verbatim in the generated documentation.

- Use defproc to document the procedure.

Adding these pieces to "manual.scrbl" gives us the following:

> #lang scribble/manual
> @(require (for-label racket
> "helper.rkt"))
> @title{My Library}
> @defmodule[my-lib/helper]
> @defproc[(my-helper [lst list?])
> (listof
> (not/c (one-of/c 'cow)))]{
> Replaces each @racket['cow] in @racket[lst] with
> @racket['aardvark].}

In defproc, a contract is specified with each argument to the procedure. In this example, the contract for the lst argument is list?, which is the contract for a list. After the closing parenthesis that ends the argument sequence, the contract of the result must be given; in this case, my-helper guarantees a result that is a list where none of the elements are 'cow.

Some things to notice in this example and the documentation that it generates:

- The list?, listof, etc. elements of contracts are hyperlinked to their documentation.

- The result contract is formatted in the generated documentation in the same way as in the source. That is, the source layout of contracts is preserved. (In this case, putting the contract all on one line would be better.)

- In the prose that documents my-helper, lst is automatically typeset in italic, matching the typesetting in the blue box. The racket form essentially knows that it’s used in the scope of a procedure with argument lst.

- If you hover the mouse pointer over my-helper, a popup reports that it is provided from my-lib/helper.

- If you use my-helper in any documentation now, as long as that documentation source also has a (require (for-label ....)) of "helper.rkt", then the reference is hyperlinked to the definition above.

See defproc*, defform, etc. for more information on forms to document Racket bindings.

##### 4.1.5`` Showing Racket Examples

The examples form from scribble/eval helps you generate examples in your documentation. To use examples, the procedures to document must be suitable for use at documentation time, but the examples form does not use any binding introduced into the document source by require. Instead, create a new evaluator with its own namespace using make-base-eval, and use interaction-eval to require "helper.rkt" in that evaluator. Finally, supply the same evaluator to examples:

> #lang scribble/manual
> @(require scribble/eval
> (for-label racket
> "helper.rkt"))
> @title{My Library}
> @defmodule[my-lib/helper]
> @defproc[(my-helper [lst list?])
> (listof
> (not/c (one-of/c 'cow)))]{
> Replaces each @racket['cow] in @racket[lst] with
> @racket['aardvark].
> @(define helper-eval (make-base-eval))
> @interaction-eval[#:eval helper-eval
> (require "helper.rkt")]
> @examples[
> #:eval helper-eval
> (my-helper '())
> (my-helper '(cows such remarkable cows))
> ]}

##### 4.1.6`` Multi-Page Sections

Setting the 'multi-page option (see Section Hyperlinks) causes each top-level section of a document to be rendered as a separate HTML page.

To push sub-sections onto separate pages, use the 'toc style for the enclosing section (as started by title, section, subsection, etc.) and use local-table-of-contents to generate hyperlinks to the sub-sections.

Revising "cows.scrbl" from the previous section:

> #lang scribble/manual
> @title[#:style '(toc)]{Cows}
> @local-table-of-contents[]
> @section[#:tag "singing"]{Singing}
> Wherever they go, it's a quite a show.
> @section{Dancing}
> See @secref["singing"].

To run this example, remember to change "info.rkt" to add the 'multi-page style. You may also want to add a call to table-of-contents in "manual.scrbl".

The difference between table-of-contents and local-table-of-contents is that the latter is ignored for Latex output.

When using local-table-of-contents, it often makes sense to include introductory text before the call of local-table-of-contents. When the introductory text is less important and when local table of contents is short, putting the introductory text after the call of local-table-of-contents may be appropriate.

top ← prev up next →