►Rhombus Scribble
▼3 Core Scribble
On this page:
Part
Part.tag_  prefix
Part.tags
Part.title_  content
Part.style
Part.to_  collect
Part.blocks
Part.parts
Part.context_  accumulation
Paragraph
Paragraph
Paragraph.style
Paragraph.content
Table
Table
Table.style
Table.blockss
Itemization
Itemization
Itemization.style
Itemization.blockss
Nested  Flow
Nested  Flow
Nested  Flow.style
Nested  Flow.blocks
Compound  Paragraph
Compound  Paragraph
Compound  Paragraph.style
Compound  Paragraph.blocks
Traverse  Block
Traverse  Block
Traverse  Block.traverse
Traverse  Block  Function
Delayed  Block
Delayed  Block
Delayed  Block.resolve
Multiarg  Element
Multiarg  Element
Multiarg  Element.style
Multiarg  Element.contents
Traverse  Element
Traverse  Element
Traverse  Element.traverse
Traverse  Element  Function
Part  Relative  Element
Part  Relative  Element
Part  Relative  Element.collect
Part  Relative  Element.sizer
Part  Relative  Element.plain
Collect  Element
Collect  Element
Collect  Element.style
Collect  Element.content
Collect  Element.collect
Delayed  Element
Delayed  Element
Delayed  Element.resolve
Delayed  Element.sizer
Delayed  Element.plain
Render  Element
Render  Element
Render  Element.resolve
Collect  Info
Resolve  Info
9.0.0.6
  top  contents    up   

3.10 Additional Datatypes🔗ℹ

function

fun Part(

  ~tag_prefix: tag_prefix :: maybe(String || Map) = #false,

  ~tags: tags :: Listable.to_list && List.of(Tag) = [],

  ~title_content: title_content :: maybe(Content) = #false,

  ~style: part_style :: Style = Style.plain,

  ~to_collect: to_collect :: Content = [],

  ~blocks: blocks :: Listable.to_list && List.of(FlowBlock) = [],

  ~parts: parts :: Listable.to_list && List.of(Part) = []

) :: Part

 

property

property (p :: Part).tag_prefix :: maybe(String || Map)

 

property

property (p :: Part).tags :: PairList.of(Tag)

 

property

property (p :: Part).title_content :: maybe(Content)

 

property

property (p :: Part).style :: Style

 

property

property (p :: Part).to_collect :: Content

 

property

property (p :: Part).blocks :: PairList.of(FlowBlock)

 

property

property (p :: Part).parts :: PairList.of(Part)

 

function

fun Part.context_accumulation(key :: Any) :: Any

See Part for general information about parts.

The Part veneer recognizes the same values as the Racket Scribble library’s part?. The Part function constructs such a value given its components:

  • tag_prefix: a tag prefix and/or part context accumulation.

  • tags: A list of tags that each link to the section represented by the part. Normally, tags should be a non-empty list, so that hyperlinks can target the section.

  • title_content: The part’s title, if any.

  • part_style: See part_style for more information about styles for parts.

  • to_collect: Content that is inspected during the collect pass, but ignored in later passes, so it doesn’t directly contribute to the part’s rendered form.

  • blocks: The part’s content, rendered before any subparts.

  • parts: Subparts, which represent subsections of the part.

See Part Context for information about Part.context_accumulation.

veneer

veneer Paragraph

 

function

fun Paragraph(

  ~style: style :: Style = Style.plain,

  content :: Content = []

) :: Paragraph

 

property

property (p :: Paragraph).style :: Style

 

property

property (p :: Paragraph).content :: Content

Represents a paragraph. Normally, a paragraph is created with para or by decoding.

The Paragraph veneer recognizes the same values as the Racket Scribble library’s paragraph?.

veneer

veneer Table

 

function

fun Table(

  ~style: style :: Style = Style.plain,

  blockss :: (Listable.to_list

                && List.of(Listable.to_list)

                && List.of(List.of(Cell))) = []

) :: Table

 

property

property (t :: Table).style :: Style

 

property

property (t :: Table).blockss :~ PairList.of(PairList.of(FlowBlock))

Represents a table. Normally, a table is created with tabular.

The Table veneer recognizes the same values as the Racket Scribble library’s table?.

veneer

veneer Itemization

 

function

fun Itemization(

  ~style: style :: Style = Style.plain,

  blockss :: (Listable.to_list

                && List.of(Listable.to_list)

                && List.of(List.of(FlowBlock))) = []

) :: Itemization

 

property

property (i :: Itemization).style :: Style

 

property

property (i :: Itemization).blockss

  :: PairList.of(PairList.of(FlowBlock))

Represents an itemization. Normally, an itemization is created with itemlist.

The Itemization veneer recognizes the same values as the Racket Scribble library’s itemization?.

veneer

veneer NestedFlow

 

function

fun NestedFlow(

  ~style: style :: Style = Style.plain,

  blocks :: Listable.to_list && List.of(List.of(FlowBlock)) = []

) :: NestedFlow

 

property

property (nf :: NestedFlow).style :: Style

 

property

property (nf :: NestedFlow).blocks :: PairList.of(FlowBlock)

Represents a nested flow. Normally, an itemization is created with nested.

The NestedFlow veneer recognizes the same values as the Racket Scribble library’s nested-flow?.

veneer

veneer CompoundParagraph

 

function

fun CompoundParagraph(

  ~style: style :: Style = Style.plain,

  blocks :: Listable.to_list && List.of(List.of(FlowBlock)) = []

) :: CompoundParagraph

 

property

property (cp :: CompoundParagraph).style :: Style

 

property

property (cp :: CompoundParagraph).blocks :: PairList.of(FlowBlock)

Represents a compound paragraph. Normally, a compound paragraph is created by decoding.

The CompoundParagraph veneer recognizes the same values as the Racket Scribble library’s compound-paragraph?.

veneer

veneer TraverseBlock

 

function

fun TraverseBlock(

  ~traverse: traverse :: TraverseBlockFunction

) :: TraverseBlock

 

property

property (tb :: TraverseBlock).traverse :: TraverseBlockFunction

 

annotation

TraverseBlockFunction

Represents a flow block that participates directly in the traverse pass.

A TraverseBlockFunction for traverse satisifes

(Any -> Any, (Any, Any) -> Void) -> FlowBlock || TraverseBlockFunction

where the first argument to a TraverseBlockFunction is a get function that takes a key and results a value, and the second argument is a set function that takes a key and a new value for the key. The result of a TraverseBlockFunction must be either a replacement FlowBlock or another TraverseBlockFunction function to participate in the next iteration of the traverse pass.

The TraverseBlock veneer recognizes the same values as the Racket Scribble library’s traverse-block?.

veneer

veneer DelayedBlock

 

function

fun DelayedBlock(

  ~resolve: resolve :: (Any, Part, ResolveInfo) -> FlowBlock

) :: DelayedBlock

 

property

property (db :: DelayedBlock).resolve

  :: (Any, Part, ResolveInfo) -> FlowBlock

Represents a flow block that participates directly in the resolve pass. The resolve function produces a block that serves as replacement for the DelayedBlock after it is resolved.

The DelayedBlock veneer recognizes the same values as the Racket Scribble library’s delayed-block?.

veneer

veneer MultiargElement

 

function

fun MultiargElement(

  contents  :: Listable.to_list && List.of(Content),

  ~style: style :: maybe(Style || String || Symbol) = #false

) :: MultiargElement

 

property

property (e :: MultiargElement).style

  :: maybe(Style || String || Symbol)

 

property

property (e :: MultiargElement).contents :: PairList.of(Content)

Like Element, but for Latex-backed renderers that have multiple-argument styles. Specifically, the name of style is used as the name of a Latex macro that accepts as many arguments as elements in contents.

The MultiargElement veneer recognizes the same values as the Racket Scribble library’s multiarg-element?.

veneer

veneer TraverseElement

 

function

fun TraverseElement(

  ~traverse: traverse :: TraverseElementFunction

) :: TraverseElement

 

property

property (e :: TraverseElement).traverse

  :: TraverseElementFunction

 

annotation

TraverseElementFunction

Represents content that participates directly in the traverse pass.

A TraverseElementFunction for traverse satisifes

(Any -> Any, (Any, Any) -> Void) -> Content || TraverseElementFunction

analogous to TraverseBlockFunction.

The TraverseElement veneer recognizes the same values as the Racket Scribble library’s traverse-element?.

veneer

veneer PartRelativeElement

 

function

fun PartRelativeElement(

  ~collect: collect :: CollectInfo -> Content,

  ~sizer: sizer :: () -> Any,

  ~plain: plain :: () -> Any

) :: PartRelativeElement

 

property

property (e :: PartRelativeElement).collect

  :: CollectInfo -> Content

 

property

property (e :: PartRelativeElement).sizer :: () -> Any

 

property

property (e :: PartRelativeElement).plain :: () -> Any

Represents content that participates directly in the collect pass.

The PartRelativeElement veneer recognizes the same values as the Racket Scribble library’s part-relative-element?.

veneer

veneer CollectElement:

  extends Element

 

function

fun CollectElement(

  ~style: style :: maybe(Style || String || Symbol) = #false,

  content :: Content = [],

  ~collect: collect :: CollectInfo -> Any

) :: CollectElement

 

property

property (e :: CollectElement).style

  :: maybe(Style || String || Symbol)

 

property

property (e :: CollectElement).content :: COntent

 

property

property (e :: CollectElement).collect

  :: CollectInfo -> Any

Represents content that participates directly in the collect pass—similar to PartRelativeElement, but as a value that also satisifies Element and that does not produce a replacement for itself.

The CollectElement veneer recognizes the same values as the Racket Scribble library’s collect-element?.

veneer

veneer DelayedElement

 

function

fun DelayedElement(

  ~resolve: resolve :: (Any, Part, ResolveInfo) -> Content,

  ~sizer: sizer :: () -> Any,

  ~plain: plain :: () -> Any

) :: DelayedElement

 

property

property (e :: DelayedElement).resolve

  :: (Any, Part, ResolveInfo) -> Content

 

property

property (e :: DelayedElement).sizer :: () -> Any

 

property

property (e :: DelayedElement).plain :: () -> Any

Represents content that participates directly in the resolve pass.

The DelayedElement veneer recognizes the same values as the Racket Scribble library’s delayed-element?.

veneer

veneer RenderElement:

  extends Element

 

function

fun RenderElement(

  ~resolve: resolve :: (Any, Part, ResolveInfo) -> Content

) :: RenderElement

 

property

property (e :: RenderElement).resolve

  :: (Any, Part, ResolveInfo) -> Content

Represents content that participates directly in the render pass.

The RenderElement veneer recognizes the same values as the Racket Scribble library’s render-element?.

annotation

CollectInfo

 

annotation

ResolveInfo

A CollectInfo object contains accumulated, part-local information gathered in the collect pass to set up cross-reference targets. The CollectInfo annotation recognizes the same values as the Racket Scribble library’s collect-info?..

A ResolveInfo object contains information gathered in the resolve pass. The ResolveInfo annotation recognizes the same values as the Racket Scribble library’s resolve-info?..

  top  contents    up