► |  | 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.7 | Compatibility Libraries

4.7.1 | Compatibility Structures And Processing
4.7.2 | Compatibility Basic Functions

On this page:

4.7.1`` Compatibility Structures And Processing
make-part
part-flow
part-title-content
make-versioned-part
versioned-part?
make-unnumbered-part
unnumbered-part?
make-paragraph
paragraph-content
make-styled-paragraph
styled-paragraph?
styled-paragraph-style
make-omitable-paragraph
omitable-paragraph?
make-table
table-flowss
make-itemization
make-styled-itemization
styled-itemization?
styled-itemization-style
make-blockquote
make-auxiliary-table
auxiliary-table?
make-compound-paragraph
make-element
make-toc-element
make-target-element
make-toc-target-element
make-toc-target2-element
make-page-target-element
make-redirect-target-element
make-link-element
make-index-element
element?
element-content
element-style
make-aux-element
make-hover-element
make-script-element
with-attributes
target-url
image-file
element->string
4.7.2`` Compatibility Basic Functions
span-class
itemize

6.8
top ← prev up next →

#### 4.7`` Compatibility Libraries

##### 4.7.1`` Compatibility Structures And Processing

(require scribble/struct) | package: scribble-lib

The scribble/struct compatibility library mostly re-exports scribble/core, but using some different names (e.g., blockquote instead of nested-flow).

The following structure types and functions are re-exported directly:

> collect-info resolve-info tag? block?
> delayed-block collected-info delayed-element
> part-relative-element collect-info-parents
> collect-element render-element generated-tag
> tag-key content->string element->string
> block-width element-width
> info-key? part-collected-info collect-put!
> resolve-get resolve-get/tentative resolve-get/ext?
> resolve-search resolve-get-keys

The following structure types are re-exported, but the constructors and some selectors are replaced as documented further below:

> part paragraph table itemization compound-paragraph
> element toc-element target-element toc-target-element toc-target2-element
> page-target-element redirect-target-element link-element
> index-element

Several additional compatibility functions and structure types are also exported.

> > procedure
> > (make-part |  | tag-prefix |  |  |  |
> > |  | tags |  |  |  |
> > |  | title-content |  |  |  |
> > |  | style |  |  |  |
> > |  | to-collect |  |  |  |
> > |  | blocks |  |  |  |
> > |  | parts) |  | → |  | part?
> tag-prefix : (or/c false/c string?)
> tags : (listof tag?)
> title-content : (or/c false/c list?)
> style : any/c
> to-collect : list?
> blocks : (listof block?)
> parts : (listof part?)

For backward compatibility. Compared to the normal constructor for part, parses style to convert old formats to the current one. Also, if title-content is a list with a single item, the item by itself is stored in the resulting part.

> procedure (part-flow p) → (listof block?)
> p : part?

For backward compatibility. An alias for part-blocks.

> procedure (part-title-content p) → list?
> p : part?

For backward compatibility. Like the normal selector, but if the result would not be a list, it is coerced to one.

> > procedure
> > (make-versioned-part |  | tag-prefix |  |  |  |
> > |  | tags |  |  |  |
> > |  | title-content |  |  |  |
> > |  | style |  |  |  |
> > |  | to-collect |  |  |  |
> > |  | blocks |  |  |  |
> > |  | parts |  |  |  |
> > |  | version) |  | → |  | part?
> tag-prefix : (or/c false/c string?)
> tags : (listof tag?)
> title-content : (or/c false/c list?)
> style : any/c
> to-collect : list?
> blocks : (listof block?)
> parts : (listof part?)
> version : string?
> procedure (versioned-part? v) → boolean?
> v : any/c

For backward compatibility. Like make-part, but adds a the document-version style property using the given version. The versioned-part? predicate recognizes a part with a document-version property.

> > procedure
> > (make-unnumbered-part |  | tag-prefix |  |  |  |
> > |  | tags |  |  |  |
> > |  | title-content |  |  |  |
> > |  | style |  |  |  |
> > |  | to-collect |  |  |  |
> > |  | blocks |  |  |  |
> > |  | parts) |  | → |  | part?
> tag-prefix : (or/c false/c string?)
> tags : (listof tag?)
> title-content : (or/c false/c list?)
> style : any/c
> to-collect : list?
> blocks : (listof block?)
> parts : (listof part?)
> procedure (unnumbered-part? v) → boolean?
> v : any/c

For backward compatibility. Like make-part, but adds the 'unnumbered style property. The unnumbered-part? predicate recognizes a part with the 'unnumbered property.

> procedure (make-paragraph content) → paragraph?
> content : list?

For backward compatibility. Compared to the normal constructor for paragraph, omits a style argument. Also, if content is a list containing a single item, the item by itself is stored in the resulting paragraph.

> procedure (paragraph-content p) → list?
> p : paragraph?

For backward compatibility. Like the normal selector, but if the result would not be a list, it is coerced to one.

> procedure (make-styled-paragraph content style) → paragraph?
> content : list?
> style : any/c
> procedure (styled-paragraph? v) → boolean?
> v : any/c
> procedure (styled-paragraph-style p) → style?
> p : paragraph?

For backward compatibility. Compared to the normal constructor for paragraph, parses style to convert old formats to the current one. The styled-paragraph? predicate and styled-paragraph-style accessor are aliases for paragraph? and paragraph-style.

> procedure (make-omitable-paragraph content) → paragraph?
> content : list?
> procedure (omitable-paragraph? v) → boolean?
> v : any/c

For backward compatibility. Like make-paragraph, but adds the 'omitable style property. The omitable-paragraph? predicate checks for a paragraph with the property.

> procedure (make-table style blocksss) → table?
> style : any/c
> blocksss : (listof (listof (or/c (listof block?) (one-of/c 'cont))))

For backward compatibility. Compared to the normal constructor for table, the style is converted, and each cell has a list of blocks instead of a single block. If any such list has multiple blocks, they are combined into a nested-flow.

> procedure (table-flowss table)
> → (listof (listof (or/c (listof block?) (one-of/c 'cont))))
> table : table?

For backward compatibility. Like table-blockss, but adds a list wrapper to be consistent with make-table.

> procedure (make-itemization blockss) → itemization?
> blockss : (listof (listof block?))

For backward compatibility. Compared to the normal constructor for itemization, omits a style argument.

> procedure (make-styled-itemization style blockss) → itemization?
> style : any/c
> blockss : (listof (listof block?))
> procedure (styled-itemization? v) → boolean?
> v : any/c
> procedure (styled-itemization-style i) → style?
> i : itemization?

For backward compatibility. Compared to the normal constructor for itemization, parses style to convert old formats to the current one. The styled-itemization? predicate is an alias for itemization?, and styled-itemization-style is an alias for itemization-style.

> procedure (make-blockquote style blocks) → nested-flow?
> style : any/c
> blocks : (listof block?)

For backward compatibility. Like make-nested-flow, but style is parsed to the current format.

> procedure (make-auxiliary-table style blocksss) → table?
> style : any/c
> blocksss : (listof (listof (or/c (listof block?) (one-of/c 'cont))))
> procedure (auxiliary-table? v) → boolean?
> v : any/c

For backward compatibility. Like make-table, but adds the 'aux style property. The auxiliary-table? predicate recognizes tables with the 'aux property.

> procedure (make-compound-paragraph style blocks) → compound-paragraph?
> style : any/c
> blocks : (listof block?)

For backward compatibility. Compared to the normal constructor for compound-paragraph, parses style to convert old formats to the current one.

> procedure (make-element style content) → element?
> style : any/c
> content : list?
> procedure (make-toc-element style content toc-content) → toc-element?
> style : any/c
> content : list?
> toc-content : list?
> procedure (make-target-element style content tag) → target-element?
> style : any/c
> content : list?
> tag : tag?
> procedure (make-toc-target-element style content tag) → toc-target-element?
> style : any/c
> content : list?
> tag : tag?
> > procedure
> > (make-toc-target2-element |  | style |  |  |  |
> > |  | content |  |  |  |
> > |  | tag |  |  |  |
> > |  | toc-content) |  | → |  | toc-target2-element?
> style : any/c
> content : list?
> tag : tag?
> toc-content : content?
> procedure (make-page-target-element style content tag)
> → page-target-element?
> style : any/c
> content : list?
> tag : tag?
> > procedure
> > (make-redirect-target-element |  | style |
> > |  | content |
> > |  | tag |
> > |  | alt-path |
> > |  | alt-anchor) |
> → redirect-target-element?
> style : any/c
> content : list?
> tag : tag?
> alt-path : path-string?
> alt-anchor : string?
> procedure (make-link-element style content tag) → link-element?
> style : any/c
> content : list?
> tag : tag?
> > procedure
> > (make-index-element |  | style |  |  |  |
> > |  | content |  |  |  |
> > |  | tag |  |  |  |
> > |  | plain-seq |  |  |  |
> > |  | entry-seq |  |  |  |
> > |  | desc) |  | → |  | index-element?
> style : any/c
> content : list?
> tag : tag?
> plain-seq : (and/c pair? (listof string?))
> entry-seq : list?
> desc : any/c

For backward compatibility. Compared to the normal constructors, parses style to convert old formats to the current one.

> procedure (element? v) → boolean?
> v : any/c
> procedure (element-content e) → list?
> e : element?
> procedure (element-style e) → element-style?
> e : element?

For backward compatibility. A content list is treated as an element by these functions, and the result of element-content is always a list.

> procedure (make-aux-element style content) → element?
> style : any/c
> content : list?

For backward compatibility. Like make-element, but adds the 'aux style property.

> procedure (make-hover-element style content text) → element?
> style : any/c
> content : list?
> text : string?

For backward compatibility. Like make-element, but adds hover-property containing text to the element’s style.

> > procedure
> > (make-script-element |  | style |  |  |  |
> > |  | content |  |  |  |
> > |  | type |  |  |  |
> > |  | script) |  | → |  | element?
> style : any/c
> content : list?
> type : string?
> script : (or/c path-string? (listof string?))

For backward compatibility. Like make-element, but adds script-property containing type and script to the element’s style.

> > struct
> > (struct |  | with-attributes (style assoc)
> #:extra-constructor-name make-with-attributes)
> style : any/c
> assoc : (listof (cons/c symbol? string?))

For backward compatibility. Used for an element’s style to combine a base style with arbitrary HTML attributes. When the style field is itself an instance of with-attributes, its content is automatically flattened into the enclosing with-attributes when it is used (when, e.g., rendering an element or paragraph).

> > struct
> > (struct |  | target-url (addr style)
> #:extra-constructor-name make-target-url)
> addr : path-string?
> style : any/c

For backward compatibility. Used as a style for an element. The style at this layer is a style for the hyperlink.

> > struct
> > (struct |  | image-file (path scale)
> #:extra-constructor-name make-image-file)
> | path |  | : |  |
> (or/c path-string?
> (cons/c 'collects (listof bytes?)))
> scale : real?

For backward compatibility. Used as a style for an element to inline an image. The path field can be a result of path->main-collects-relative.

> procedure (element->string element) → string?
> element : content?
> (element->string element renderer p info) → string?
> element : content?
> renderer : any/c
> p : part?
> info : resolve-info?

For backward compatibility. An alias for content->string.

##### 4.7.2`` Compatibility Basic Functions

(require scribble/basic) | package: scribble-lib

The scribble/basic compatibility library mostly just re-exports scribble/base.

> procedure (span-class style-name pre-content ...) → element?
> style-name : string?
> pre-content : any/c

For backward compatibility. Wraps the decoded pre-content as an element with style style-name.

> procedure (itemize itm ... [#:style style]) → itemization?
> itm : (or/c whitespace? an-item?)
> style : (or/c style? string? symbol? #f) = #f

For backward compatibility. Like itemlist, but whitespace strings among the itms are ignored.
top ← prev up next →