But not this one.
"}]}}]}],"metadata":{"assignedNumber":2,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":31,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"quote-syntax"}}},"subParts":[],"title":[{"text":"Quotes"}],"titleString":"Quotes"},{"content":[{"para":[{"other":{"container":{"data":["code block","Code blocks"],"id":34,"name":"Verso.Genre.Manual.deftech"},"content":[{"text":"Code blocks"}]}},{"text":" begin with three or more back-ticks at the start of a line (they may be preceded by spaces)."},{"linebreak":"\n"},{"text":"This is referred to as a "},{"other":{"container":{"data":["fence","fence"],"id":35,"name":"Verso.Genre.Manual.deftech"},"content":[{"emph":[{"text":"fence"}]}]}},{"text":"."},{"linebreak":"\n"},{"text":"They may optionally have a name and a sequence of arguments after the back-ticks."},{"linebreak":"\n"},{"text":"The code block continues until a line that contains only the same number of back-ticks at the same indentation."},{"linebreak":"\n"},{"text":"Every line in the code block must be at least as indented as the fence, and it denotes the string that results from removing the indentation from each line."},{"linebreak":"\n"},{"text":"Code blocks may not contain a sequence of back-ticks that is at least as long as the fence; to add more back-ticks to the code block, the fence must be made larger."}]},{"concat":[{"other":{"container":{"data":"Code Blocks","id":36,"name":"MarkupExample","properties":{}},"content":[{"code":"```\nThis is a code block\nwith two lines\n```\n"},{"code":""},{"text":" tag in HTML."},{"linebreak":"\n"},{"text":"Directives begin with three or more colons and a name with zero or more arguments, and end with the same number of colons at the same indentation on a line by themselves."},{"linebreak":"\n"},{"text":"They may contain any number of blocks, which must be indented at least as much as the colons."},{"linebreak":"\n"},{"text":"Nested directives must begin and end with strictly fewer colons than the surrounding directives."}]},{"para":[{"text":"The "},{"other":{"container":{"data":{"canonicalName":"extensions","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Extensions/#extensions"},"id":622,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"chapter on Verso markup extensions"}]}},{"text":" describes the processing of directives in more detail."}]},{"para":[{"text":"This is an empty directive:"}]},{"concat":[{"other":{"container":{"data":"Directives","id":44,"name":"MarkupExample","properties":{}},"content":[{"code":":::nothing\n:::\n"},{"code":"
"}]}}]},{"para":[{"text":"This directive contains a directive and a paragraph:"}]},{"concat":[{"other":{"container":{"data":"Nested Directives","id":45,"name":"MarkupExample","properties":{}},"content":[{"code":"::::outer\n:::inner\nHello\n:::\nThis is a paragraph\n::::\n"},{"code":"
\n Hello
\n This is a paragraph
\n"}]}}]}],"metadata":{"assignedNumber":4,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":41,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"directive-syntax"}}},"subParts":[],"title":[{"text":"Directives"}],"titleString":"Directives"},{"content":[{"para":[{"text":"A line that consists of only a set of curly braces that contain a name and zero or more arguments is a "},{"other":{"container":{"data":["command","command"],"id":47,"name":"Verso.Genre.Manual.deftech"},"content":[{"emph":[{"text":"command"}]}]}},{"text":"."},{"linebreak":"\n"},{"text":"The name is used to select an implementation for the command, which is then invoked during elaboration."},{"linebreak":"\n"},{"text":"The "},{"other":{"container":{"data":{"canonicalName":"extensions","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Extensions/#extensions"},"id":623,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"chapter on Verso markup extensions"}]}},{"text":" has more details on this process."}]},{"concat":[{"other":{"container":{"data":"Commands","id":49,"name":"MarkupExample","properties":{}},"content":[{"code":"{include 0 MyChapter}\n"},{"code":"
"}]}}]}],"metadata":{"assignedNumber":5,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":46,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"command-block-syntax"}}},"subParts":[],"title":[{"text":"Commands"}],"titleString":"Commands"}],"title":[{"text":"Block Syntax"}],"titleString":"Block Syntax"},{"content":[{"para":[{"text":"Emphasis is written with underscores:"}]},{"concat":[{"other":{"container":{"data":"Emphasis","id":51,"name":"MarkupExample","properties":{}},"content":[{"code":"Here's some _emphasized_ text\n"},{"code":"
\n Here's some\n emphasized text\n
"}]}}]},{"para":[{"text":"Emphasis can be nested by using more underscores for the outer emphasis:"}]},{"concat":[{"other":{"container":{"data":"Nested Emphasis","id":52,"name":"MarkupExample","properties":{}},"content":[{"code":"Here's some __emphasized text\nwith _extra_ emphasis__ inside\n"},{"code":"
\n Here's some\n \n emphasized text with\n extra emphasis\n \n inside\n
"}]}}]},{"para":[{"text":"Strong emphasis (bold) is written with asterisks:"}]},{"concat":[{"other":{"container":{"data":"Strong Emphasis (Bold)","id":53,"name":"MarkupExample","properties":{}},"content":[{"code":"Here's some *bold* text\n"},{"code":"
\n Here's some bold\n text\n
"}]}}]},{"para":[{"text":"Hyperlinks consist of the link text in square brackets followed by the target in parentheses:"}]},{"concat":[{"other":{"container":{"data":"Links","id":54,"name":"MarkupExample","properties":{}},"content":[{"code":"[Lean](https://lean-lang.org)\n"},{"code":"
\n \n Lean\n \n
"}]}}]},{"para":[{"text":"Link targets may also be named:"}]},{"concat":[{"other":{"container":{"data":"Named Link Targets","id":55,"name":"MarkupExample","properties":{}},"content":[{"code":"The [Lean website][lean]\n\n[lean]: https://lean-lang.org\n"},{"code":"
\n The\n Lean\n website\n
\n\nwhere\n «lean» := https://lean-lang.org"}]}}]},{"para":[{"text":"Literal code elements are written in back-ticks."},{"linebreak":"\n"},{"text":"The same number of back-ticks that opens a code element must be used to close it, and the code element may not contain a sequence of back-ticks that's at least as long as its opener and closer."}]},{"concat":[{"other":{"container":{"data":"Literal Code","id":56,"name":"MarkupExample","properties":{}},"content":[{"code":"The definition of `main`\n"},{"code":"
\n The definition of\n \"main\"\n
"}]}}]},{"para":[{"text":"As a special case, code inlines that being and end with a space denote the string that results from removing one leading and trailing space."},{"linebreak":"\n"},{"text":"This makes it possible to represent values that begin or end with back-ticks:"}]},{"concat":[{"other":{"container":{"data":"Spaces in Code","id":57,"name":"MarkupExample","properties":{}},"content":[{"code":"`` `quotedName ``\n"},{"code":"
\"`quotedName\"
"}]}}]},{"para":[{"text":"or with spaces:"}]},{"concat":[{"other":{"container":{"data":"Multiple Spaces in Code","id":58,"name":"MarkupExample","properties":{}},"content":[{"code":"`` one space ``\n"},{"code":"
\" one space \"
"}]}}]},{"concat":[{"other":{"container":{"data":null,"id":59,"name":"Verso.Genre.Manual.Block.paragraph","properties":{}},"content":[{"para":[{"text":"Images require both alternative text and an address for the image:"}]},{"concat":[{"other":{"container":{"data":"Images","id":60,"name":"MarkupExample","properties":{}},"content":[{"code":"\n"},{"code":"
\n \n
"}]}}]},{"concat":[{"other":{"container":{"data":"Named Image Addresses","id":61,"name":"MarkupExample","properties":{}},"content":[{"code":"![Alternative text][image]\n\n[image]: image.png\n"},{"code":"
\n \n
\n\nwhere «image» := image.png"}]}}]}]}}]},{"para":[{"text":"TeX math can be included using a single or double dollar sign followed by code. Two dollar signs results in display-mode math, so "},{"code":"$`\\sum_{i=0}^{10} i`"},{"text":" results in "},{"math":{"mode":"inline","str":"\\sum_{i=0}^{10} i"}},{"text":" while "},{"code":"$$`\\sum_{i=0}^{10} i`"},{"text":" results in: "},{"math":{"mode":"display","str":"\\sum_{i=0}^{10} i"}}]},{"para":[{"text":"A "},{"other":{"container":{"data":["role","role"],"id":62,"name":"Verso.Genre.Manual.deftech"},"content":[{"emph":[{"text":"role"}]}]}},{"text":" indicates that subsequent inlines have a special meaning."},{"linebreak":"\n"},{"text":"Roles can be used to trigger special handling of code (e.g. elaboration), register definitions and uses of technical terms, add marginal notes, and much more."},{"linebreak":"\n"},{"text":"They correspond to custom commands in LaTeX."},{"linebreak":"\n"},{"text":"A role consists of curly braces that contain a name and arguments, all on the same line, followed immediately either by a self-delimiting inline or by square brackets that contain zero or more inlines."}]},{"para":[{"text":"An inline is "},{"other":{"container":{"data":["self delimiting","self-delimiting"],"id":63,"name":"Verso.Genre.Manual.deftech"},"content":[{"emph":[{"text":"self-delimiting"}]}]}},{"text":" if it has distinct start and end tokens that make its ending position clear."},{"linebreak":"\n"},{"text":"Emphasis, strong emphasis, code, links, images, math, and roles are self-delimiting."}]},{"concat":[{"other":{"container":{"data":null,"id":64,"name":"Verso.Genre.Manual.Block.paragraph","properties":{}},"content":[{"para":[{"text":"This role contains multiple inlines using square brackets:"}]},{"concat":[{"other":{"container":{"data":"Roles With Explicit Scope","id":65,"name":"MarkupExample","properties":{}},"content":[{"code":"{ref \"chapter-tag\"}[the chapter on\n$`\\frac{1}{2}`-powered syntax]\n"},{"code":"
\n [\n the chapter on \n ]\n
"}]}}]},{"para":[{"text":"This one takes a single inline code element without needing square brackets:"}]},{"concat":[{"other":{"container":{"data":"Single-Argument Roles","id":66,"name":"MarkupExample","properties":{}},"content":[{"code":"{lean}`2 + f 4`\n"},{"code":"
\n \n \"2 + f 4\"\n \n
"}]}}]}]}}]}],"metadata":{"assignedNumber":3,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":50,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"inline-syntax"}}},"subParts":[],"title":[{"text":"Inline Syntax"}],"titleString":"Inline Syntax"}],"title":[{"text":"Syntax"}],"titleString":"Syntax"},{"content":[{"para":[{"text":"This is a quick \"cheat sheet\" for those who are used to Markdown, documenting the differences."}]}],"metadata":{"assignedNumber":3,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":67,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"differences-from-markdown"}}},"subParts":[{"content":[{"para":[{"text":"While Markdown includes a set of precedence rules to govern the meaning of mismatched delimiters (such as in "},{"code":"what _is *bold_ or emph*?"},{"text":"), these are syntax errors in Lean's markup."},{"linebreak":"\n"},{"text":"Similarly, Markdown specifies that unmatched delimiters (such as "},{"code":"*"},{"text":" or "},{"code":"_"},{"text":") should be included as characters, while Lean's markup requires explicit escaping of delimiters."}]},{"para":[{"text":"This is based on the principle that, for long-form technical writing, it's better to catch typos while writing than while reviewing the text later."}]}],"metadata":{"assignedNumber":1,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":68,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"syntax-errors"}}},"subParts":[],"title":[{"text":"Syntax Errors"}],"titleString":"Syntax Errors"},{"content":[{"para":[{"text":"In Markdown, whether "},{"code":"[this][here]"},{"text":" is a link depends on whether "},{"code":"here"},{"text":" is defined as a link reference target somewhere in the document."},{"linebreak":"\n"},{"text":"In Lean's markup, it is always a link, and it is an error if "},{"code":"here"},{"text":" is not defined as a link target."}]}],"metadata":{"assignedNumber":2,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":69,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"reduced-lookahead"}}},"subParts":[],"title":[{"text":"Reduced Lookahead"}],"titleString":"Reduced Lookahead"},{"content":[{"para":[{"text":"In Lean's markup, every document already has a title, so there's no need to use the highest level header ("},{"code":"#"},{"text":") to specify one."},{"linebreak":"\n"},{"text":"Additionally, all documents are required to use "},{"code":"#"},{"text":" for their top-level header, "},{"code":"##"},{"text":" for the next level, and so forth, because a single file may represent a section, a chapter, or even a whole book."},{"linebreak":"\n"},{"text":"Authors should not need to maintain a global mapping from header levels to document structures, so Lean's markup automatically assigns these based on the structure of the document."}]}],"metadata":{"assignedNumber":3,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":70,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"header-nesting"}}},"subParts":[],"title":[{"text":"Header Nesting"}],"titleString":"Header Nesting"},{"content":[{"para":[{"text":"Markdown has no standard way for specific tools or styles of writing to express domain- or "},{"other":{"container":{"data":{"canonicalName":"genres","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Genres/#genres"},"id":615,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"genre"}]}},{"text":"-specific concepts."},{"linebreak":"\n"},{"text":"Lean's markup provides standard syntaxes to use for this purpose, enabling compositional extensions."}]}],"metadata":{"assignedNumber":4,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":71,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"genre-specific-extensions"}}},"subParts":[],"title":[{"text":"Genre-Specific Extensions"}],"titleString":"Genre-Specific Extensions"},{"content":[{"para":[{"text":"Markdown has a number of features that are rarely used in practice."},{"linebreak":"\n"},{"text":"They have been removed from Verso to reduce surprises while using it and make documents more predictable."},{"linebreak":"\n"},{"text":"This includes:"}]},{"ul":[{"contents":[{"para":[{"text":"the distinction between "},{"link":{"content":[{"text":"tight"}],"url":"https://spec.commonmark.org/0.31.2/#tight"}},{"text":" and "},{"link":{"content":[{"text":"loose"}],"url":"https://spec.commonmark.org/0.31.2/#loose"}},{"text":" lists,"}]}]},{"contents":[{"para":[{"link":{"content":[{"text":"four-space indentation"}],"url":"https://spec.commonmark.org/0.31.2/#indented-code-blocks"}},{"text":" to create code blocks,"}]}]},{"contents":[{"para":[{"link":{"content":[{"text":"Setext-style headers"}],"url":"https://spec.commonmark.org/0.31.2/#setext-headings"}},{"text":", indicated with underlines instead of leading hash marks ("},{"code":"#"},{"text":"),"}]}]},{"contents":[{"para":[{"link":{"content":[{"text":"hard line break syntax"}],"url":"https://spec.commonmark.org/0.31.2/#hard-line-breaks"}},{"text":","}]}]},{"contents":[{"para":[{"text":"and "},{"link":{"content":[{"text":"HTML entities and character references"}],"url":"https://spec.commonmark.org/0.31.2/#entity-and-numeric-character-references"}}]}]}]},{"para":[{"text":"Other Markdown features don't make sense for non-HTML output, and can be implemented by a "},{"other":{"container":{"data":["genre","/home/runner/work/verso/verso/doc/UsersGuide/Markup.lean:1134:90",null],"id":74,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"genre"}]}},{"text":" using code blocks or directives."},{"linebreak":"\n"},{"text":"They have also been removed from Verso."},{"linebreak":"\n"},{"text":"In particular, this includes "},{"link":{"content":[{"text":"HTML blocks"}],"url":"https://spec.commonmark.org/0.31.2/#html-blocks"}},{"text":", "},{"link":{"content":[{"text":"raw HTML"}],"url":"https://spec.commonmark.org/0.31.2/#raw-html"}},{"text":" and "},{"link":{"content":[{"text":"thematic breaks"}],"url":"https://spec.commonmark.org/0.31.2/#thematic-breaks"}},{"text":"."}]},{"para":[{"text":"Finally, some Markdown features are used by a minority of authors, and make sense in all backends, but were not deemed worth the complexity budget."},{"linebreak":"\n"},{"text":"In particular, this includes "},{"link":{"content":[{"text":"auto-links"}],"url":"https://spec.commonmark.org/0.31.2/#autolinks"}},{"text":"."},{"linebreak":"\n"}]}],"metadata":{"assignedNumber":5,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":73,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"removed-md-features"}}},"subParts":[],"title":[{"text":"Fewer Unused Features"}],"titleString":"Fewer Unused Features"}],"title":[{"text":"Differences from Markdown"}],"titleString":"Differences from Markdown"}],"title":[{"text":"Verso Markup"}],"titleString":"Verso Markup"},{"content":[{"para":[{"text":"Verso is a general framework for implementing documentation tools, and this flexibility means that the details of the process described in this section may differ for specific tools."}]},{"para":[{"text":"A Verso document passes through the following steps on its way from its author to its readers:"}]},{"ol":{"items":[{"contents":[{"para":[{"text":"The author writes the document's text in "},{"other":{"container":{"data":{"canonicalName":"verso-markup","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Verso-Markup/#verso-markup"},"id":616,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"Verso's markup language"}]}},{"text":", which is parsed to Lean's own "},{"other":{"container":{"data":{"token":{"tok":{"content":"Syntax","kind":{"const":{"docs":"Lean syntax trees.\n\nSyntax trees are used pervasively throughout Lean: they are produced by the parser, transformed by\nthe macro expander, and elaborated. They are also produced by the delaborator and presented to\nusers.\n","isDef":false,"name":["Lean","Syntax"],"signature":"Lean.Syntax : Type"}}}}},"id":77,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Syntax"}]}},{"text":" type"}]}]},{"contents":[{"para":[{"text":"The document is elaborated to a representation as a Lean data structure"}]}]},{"contents":[{"para":[{"text":"The resulting Lean code is compiled to an executable"}]}]},{"contents":[{"para":[{"text":"When run, the executable resolves cross-references and computes other globally-scoped metadata in a step referred to as the traversal pass"}]}]},{"contents":[{"para":[{"text":"Next, the executable generates the output"}]}]}],"start":1}}],"metadata":{"assignedNumber":3,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":75,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"build-process"}}},"subParts":[{"content":[{"para":[{"text":"During the elaboration process, Verso's markup language is converted into its internal representation as a Lean inductive type."},{"linebreak":"\n"},{"text":"When Verso's elaborator encounters an "},{"other":{"container":{"data":{"canonicalName":"elab-extensions","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Extensions/#elab-extensions"},"id":624,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"extension point"}]}},{"text":", it consults an internal table to select an implementation of the extension, and delegates to it."},{"linebreak":"\n"},{"text":"Other syntax is translated into the appropriate constructors of Verso's data."}]},{"para":[{"text":"All Verso documents are parameterized by their "},{"other":{"container":{"data":["genre","/home/runner/work/verso/verso/doc/UsersGuide/Elab.lean:39:47",null],"id":80,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"genre"}]}},{"text":":"}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.Genre",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Doc.Genre.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","Genre","mk"],"signature":"Verso.Doc.Genre.mk (PartMetadata Block Inline TraverseContext TraverseState : Type) : Doc.Genre"}}}}},"name":"Verso.Doc.Genre.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Genre.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"var":{"name":"_uniq.23","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Block","kind":{"var":{"name":"_uniq.24","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Inline","kind":{"var":{"name":"_uniq.25","type":"Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"TraverseContext","kind":{"var":{"name":"_uniq.26","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"var":{"name":"_uniq.27","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":true,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Type"}}}}},"projFn":"Verso.Doc.Genre.PartMetadata","type":{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Additional block\\-level values for documents written in the genre\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Additional block\\-level values for documents written in the genre\\.\n ","isDef":true,"name":["Verso","Doc","Genre","Block"],"signature":"Type"}}}}},"projFn":"Verso.Doc.Genre.Block","type":{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Additional inline\\-level values for documents written in the genre\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Additional inline\\-level values for documents written in the genre\\.\n ","isDef":true,"name":["Verso","Doc","Genre","Inline"],"signature":"Type"}}}}},"projFn":"Verso.Doc.Genre.Inline","type":{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":true,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Type"}}}}},"projFn":"Verso.Doc.Genre.TraverseContext","type":{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The mutable state used in the genre's traversal pass\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":true,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Type"}}}}},"projFn":"Verso.Doc.Genre.TraverseState","type":{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},"visibility":"public"}],"fieldNames":["PartMetadata","Block","Inline","TraverseContext","TraverseState"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Genre","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Genre","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":81,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A genre is a kind of document that can be written with Verso"},{"text":"."}]},{"para":[{"text":"A genre is primarily defined by its extensions to the Verso framework, provided in this type"},{"text":"."},{"text":"\n"},{"text":"Additionally, each genre should provide a "},{"other":{"container":{"data":{"token":{"tok":{"content":"main","kind":"unknown"}}},"id":82,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"main"}]}},{"text":" function that is responsible for the traversal pass"},{"text":"\n"},{"text":"and for generating output"},{"text":"."}]},{"other":{"container":{"data":"Constructor","id":83,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Doc.Genre.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","Genre","mk"],"signature":"Verso.Doc.Genre.mk (PartMetadata Block Inline TraverseContext TraverseState : Type) : Doc.Genre"}}}}},null],"id":84,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":85,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":true,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Type"}}}}},[{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},[null,[]]]]],"id":86,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The metadata that may be associated with each "},{"other":{"container":{"data":{"token":{"tok":{"content":"Part","kind":"unknown"}}},"id":87,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Part"}]}},{"text":" "},{"text":"("},{"text":"e"},{"text":"."},{"text":"g"},{"text":"."},{"text":" author, publication date,"},{"text":"\n"},{"text":"cross"},{"text":"-"},{"text":"referencing identifier"},{"text":")"},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Additional block\\-level values for documents written in the genre\\.\n ","isDef":true,"name":["Verso","Doc","Genre","Block"],"signature":"Type"}}}}},[{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},[null,[]]]]],"id":88,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Additional block"},{"text":"-"},{"text":"level values for documents written in the genre"},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Additional inline\\-level values for documents written in the genre\\.\n ","isDef":true,"name":["Verso","Doc","Genre","Inline"],"signature":"Type"}}}}},[{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},[null,[]]]]],"id":89,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Additional inline"},{"text":"-"},{"text":"level values for documents written in the genre"},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":true,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Type"}}}}},[{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},[null,[]]]]],"id":90,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The reader"},{"text":"-"},{"text":"style data used in the genre's traversal pass"},{"text":"."},{"text":" Instances of "},{"other":{"container":{"data":{"token":{"tok":{"content":"TraversePart","kind":"unknown"}}},"id":91,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"TraversePart"}]}},{"text":" and"},{"text":"\n"},{"other":{"container":{"data":{"token":{"tok":{"content":"TraverseBlock","kind":"unknown"}}},"id":92,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"TraverseBlock"}]}},{"text":" for a genre specify how this is updated while traversing parts and blocks,"},{"text":"\n"},{"text":"respectively"},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":true,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Type"}}}}},[{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},[null,[]]]]],"id":93,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The mutable state used in the genre's traversal pass"},{"text":"."}]}]}}]}}]}}]},{"para":[{"text":"Each document consists of a "},{"other":{"container":{"data":{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},"id":94,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Part"}]}},{"text":"."},{"linebreak":"\n"},{"text":"The part's title is the title of the entire document."}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.Part",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Part","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genre","kind":{"var":{"name":"_uniq.84","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Part","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genre","kind":{"var":{"name":"_uniq.84","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":95,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A logical division of a document."}]}]}}]},{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},"id":96,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Part"}]}},{"text":"s contain "},{"other":{"container":{"data":{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},"id":97,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Block"}]}},{"text":"s:"}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.Block",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Block","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genre","kind":{"var":{"name":"_uniq.90","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Block","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genre","kind":{"var":{"name":"_uniq.90","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":98,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Block-level content in a document."}]}]}}]},{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},"id":99,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Block"}]}},{"text":"s contain "},{"other":{"container":{"data":{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},"id":100,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Inline"}]}},{"text":"s:"}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.Inline",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Inline","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genre","kind":{"var":{"name":"_uniq.96","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Inline","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genre","kind":{"var":{"name":"_uniq.96","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":101,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Inline content that is part of the text flow."}]}]}}]},{"para":[{"text":"The "},{"other":{"container":{"data":{"token":{"tok":{"content":"metadata","kind":{"const":{"docs":"Genre-specific metadata ","isDef":false,"name":["Verso","Doc","Part","metadata"],"signature":"Verso.Doc.Part.metadata {genre : Doc.Genre} : Doc.Part genre → Option genre.PartMetadata"}}}}},"id":102,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"metadata"}]}},{"text":" field of "},{"other":{"container":{"data":{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},"id":103,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Part"}]}},{"text":" typically gets its value from a metadata block written by the author, though it may be assigned more information during traversal."},{"linebreak":"\n"},{"text":"The "},{"other":{"container":{"data":{"token":{"tok":{"content":"Block.other","kind":{"const":{"docs":"A genre-specific block. `container` specifies what kind of block it is, while `content` specifies\nthe content within the block.\n","isDef":false,"name":["Verso","Doc","Block","other"],"signature":"Verso.Doc.Block.other {genre : Doc.Genre} (container : genre.Block) (content : Array (Doc.Block genre)) :\n Doc.Block genre"}}}}},"id":104,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Block.other"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Inline.other","kind":{"const":{"docs":"A genre-specific inline element. `container` specifies what kind of element it is, and `content`\nspecifies the contained elements.\n","isDef":false,"name":["Verso","Doc","Inline","other"],"signature":"Verso.Doc.Inline.other {genre : Doc.Genre} (container : genre.Inline) (content : Array (Doc.Inline genre)) :\n Doc.Inline genre"}}}}},"id":105,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Inline.other"}]}},{"text":" constructors typically result from elaborating "},{"other":{"container":{"data":{"canonicalName":"elab-extensions","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Extensions/#elab-extensions"},"id":625,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"extension points"}]}},{"text":"."}]}],"metadata":{"assignedNumber":1,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":78,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"elaboration"}}},"subParts":[],"title":[{"text":"Elaboration"}],"titleString":"Elaboration"},{"content":[{"para":[{"text":"After elaboration, the document is compiled into an executable program."},{"linebreak":"\n"},{"text":"Each genre provides a "},{"code":"main"},{"text":" function that will carry out the remainder of the steps."},{"linebreak":"\n"},{"text":"Usually, this "},{"code":"main"},{"text":" function can be applied to the part that represents the whole document; however, genres that don't have a strict linear order (such as the "},{"other":{"container":{"data":{"canonicalName":"website","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Websites/#website"},"id":626,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"website genre"}]}},{"text":") will provide their own means of configuring the document's layout."},{"linebreak":"\n"},{"text":"The "},{"code":"main"},{"text":" function typically also takes configuration parameters both in the code and on the command line, such as which output formats to generate or customizations to the generated output."}]}],"metadata":{"assignedNumber":2,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":107,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"compilation"}}},"subParts":[],"title":[{"text":"Compilation"}],"titleString":"Compilation"},{"content":[{"para":[{"text":"Because they are Lean values, Verso documents adhere to the structure of Lean programs in general."},{"linebreak":"\n"},{"text":"In particular, Lean doesn't support cyclic import graphs."},{"linebreak":"\n"},{"text":"It's common, however, for technical writing to include cyclic references; two sections that describe different aspects of something will frequently refer to one another."},{"linebreak":"\n"},{"text":"Similarly, a bibliography that's generated from a database needs a global view of a document to include only those works which are, in fact, cited."}]},{"para":[{"text":"The "},{"other":{"container":{"data":["traversal","traversal"],"id":110,"name":"Verso.Genre.Manual.deftech"},"content":[{"emph":[{"text":"traversal"}]}]}},{"text":" phase occurs at runtime, before generating output."},{"linebreak":"\n"},{"text":"During the traversal phase, the document is repeatedly traversed from beginning to end, and metadata is accumulated into a table."},{"linebreak":"\n"},{"text":"The document may also be modified during traversal; this allows the title of a section to be inserted into a cross-reference."},{"linebreak":"\n"},{"text":"This traversal is repeated until the resulting document and metadata tables are not modified; it fails if a set number of passes are executed that result in modifications each time."}]},{"para":[{"text":"Verso provides a general-purpose traversal mechanism for "},{"other":{"container":{"data":{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},"id":111,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Part"}]}},{"text":", "},{"other":{"container":{"data":{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},"id":112,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Block"}]}},{"text":", and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},"id":113,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Inline"}]}},{"text":" that genres may use."},{"linebreak":"\n"},{"other":{"container":{"data":{"token":{"tok":{"content":"Genre.TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},"id":114,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Genre.TraverseState"}]}},{"text":" contains the genre-specific information that's accumulated during traversal, while "},{"other":{"container":{"data":{"token":{"tok":{"content":"Genre.TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},"id":115,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Genre.TraverseContext"}]}},{"text":" provides a means of tracking the surrounding document context."},{"linebreak":"\n"},{"text":"To use this framework, genres should define instances of "},{"other":{"container":{"data":{"token":{"tok":{"content":"Traverse","kind":{"const":{"docs":"Genre\\-specific traversal\\.\n\nThe traversal pass is where cross\\-references are resolved\\. The traversal pass repeatedly applies a\ngenre\\-specific stateful computation until a fixed point is reached, both with respect to the state\nand the document\\. Traversal may update the state or rewrite parts of the document\\.\n\nThe methods `part`, `block`, and `inline` provide effects to be carried out before traversing the\ngiven level of the AST, and `part` allows the part's metadata to be updated\\.\n\n`genrePart` is carried out after `part`\\. It allows genre\\-specific rewriting of the entire part based\non genre\\-specific metadata\\. This is typically used to construct a table of contents or permalinks,\nbut it can in principle arbitrarily rewrite the part\\. `inPart` is used to locally transform the\ngenre's traversal context along the lines of `withReader`, and can be used to keep track of e\\.g\\. the\ncurrent position in the table of contents\\.\n\n`genreBlock` and `genreInline` are invoked when traversal encounters `Block.other` and\n`Inline.other`\\. It may rewrite them, or have state effects\\.","isDef":false,"name":["Verso","Doc","Traverse"],"signature":"Verso.Doc.Traverse (g : Doc.Genre) (m : outParam (Type → Type)) : Type 1"}}}}},"id":116,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Traverse"}]}},{"text":", which specifies the traversal of a genre's custom elements."},{"linebreak":"\n"},{"text":"Additionally, instances of "},{"other":{"container":{"data":{"token":{"tok":{"content":"GenrePart","kind":{"const":{"docs":"Specifies how to modify the context while traversing the contents of a given part\\.\n","isDef":false,"name":["Verso","Doc","TraversePart"],"signature":"Verso.Doc.TraversePart (g : Doc.Genre) : Type"}}}}},"id":117,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"GenrePart"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"GenreBlock","kind":{"const":{"docs":"Specifies how to modify the context while traversing the contents of a given block\\.\n","isDef":false,"name":["Verso","Doc","TraverseBlock"],"signature":"Verso.Doc.TraverseBlock (g : Doc.Genre) : Type"}}}}},"id":118,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"GenreBlock"}]}},{"text":" specify how traversal keeps track of the current position in a document."}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.Traverse",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Doc.Traverse.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","Traverse","mk"],"signature":"Verso.Doc.Traverse.mk {g : Doc.Genre} {m : outParam (Type → Type)}\n (part : [MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Part g → m (Option g.PartMetadata))\n (block : [MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Block g → m Unit)\n (inline : [MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Inline g → m Unit)\n (genrePart :\n [MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.PartMetadata → Doc.Part g → m (Option (Doc.Part g)))\n (genreBlock :\n [MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Block → Array (Doc.Block g) → m (Option (Doc.Block g)))\n (genreInline :\n [MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Inline → Array (Doc.Inline g) → m (Option (Doc.Inline g))) :\n Doc.Traverse g m"}}}}},"name":"Verso.Doc.Traverse.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Traverse.mk","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"outParam","kind":{"const":{"docs":"Gadget for marking output parameters in type classes.\n\nFor example, the `Membership` class is defined as:\n```\nclass Membership (α : outParam (Type u)) (γ : Type v)\n```\nThis means that whenever a typeclass goal of the form `Membership ?α ?γ` comes\nup, Lean will wait to solve it until `?γ` is known, but then it will run\ntypeclass inference, and take the first solution it finds, for any value of `?α`,\nwhich thereby determines what `?α` should be.\n\nThis expresses that in a term like `a ∈ s`, `s` might be a `Set α` or\n`List α` or some other type with a membership operation, and in each case\nthe \"member\" type `α` is determined by looking at the container type.\n","isDef":false,"name":["outParam"],"signature":"outParam.{u} (α : Sort u) : Sort u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"part","kind":{"var":{"name":"_uniq.366","type":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Part g → m (Option g.PartMetadata)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":false,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Verso.Doc.Genre.PartMetadata (self : Doc.Genre) : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"block","kind":{"var":{"name":"_uniq.379","type":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Block g → m Unit"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"inline","kind":{"var":{"name":"_uniq.392","type":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Inline g → m Unit"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genrePart","kind":{"var":{"name":"_uniq.412","type":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.PartMetadata → Doc.Part g → m (Option (Doc.Part g))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":false,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Verso.Doc.Genre.PartMetadata (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genreBlock","kind":{"var":{"name":"_uniq.432","type":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Block → Array (Doc.Block g) → m (Option (Doc.Block g))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Additional block\\-level values for documents written in the genre\\.\n ","isDef":false,"name":["Verso","Doc","Genre","Block"],"signature":"Verso.Doc.Genre.Block (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"genreInline","kind":{"var":{"name":"_uniq.452","type":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Inline → Array (Doc.Inline g) → m (Option (Doc.Inline g))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Additional inline\\-level values for documents written in the genre\\.\n ","isDef":false,"name":["Verso","Doc","Genre","Inline"],"signature":"Verso.Doc.Genre.Inline (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Traverse","kind":{"const":{"docs":"Genre\\-specific traversal\\.\n\nThe traversal pass is where cross\\-references are resolved\\. The traversal pass repeatedly applies a\ngenre\\-specific stateful computation until a fixed point is reached, both with respect to the state\nand the document\\. Traversal may update the state or rewrite parts of the document\\.\n\nThe methods `part`, `block`, and `inline` provide effects to be carried out before traversing the\ngiven level of the AST, and `part` allows the part's metadata to be updated\\.\n\n`genrePart` is carried out after `part`\\. It allows genre\\-specific rewriting of the entire part based\non genre\\-specific metadata\\. This is typically used to construct a table of contents or permalinks,\nbut it can in principle arbitrarily rewrite the part\\. `inPart` is used to locally transform the\ngenre's traversal context along the lines of `withReader`, and can be used to keep track of e\\.g\\. the\ncurrent position in the table of contents\\.\n\n`genreBlock` and `genreInline` are invoked when traversal encounters `Block.other` and\n`Inline.other`\\. It may rewrite them, or have state effects\\.","isDef":false,"name":["Verso","Doc","Traverse"],"signature":"Verso.Doc.Traverse (g : Doc.Genre) (m : outParam (Type → Type)) : Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.350","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.352","type":"outParam (Type → Type)"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"The effects carried out before traversing a `Part`\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"part","kind":{"const":{"docs":"The effects carried out before traversing a `Part`\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","part"],"signature":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Part g → m (Option g.PartMetadata)"}}}}},"projFn":"Verso.Doc.Traverse.part","type":{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":false,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Verso.Doc.Genre.PartMetadata (self : Doc.Genre) : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The effects carried out before traversing a `Block`\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"block","kind":{"const":{"docs":"The effects carried out before traversing a `Block`\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","block"],"signature":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Block g → m Unit"}}}}},"projFn":"Verso.Doc.Traverse.block","type":{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The effects carried out before traversing an `Inline`\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"inline","kind":{"const":{"docs":"The effects carried out before traversing an `Inline`\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","inline"],"signature":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Inline g → m Unit"}}}}},"projFn":"Verso.Doc.Traverse.inline","type":{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Operations carried out after `part`, when a part has metadata\\. It allows genre\\-specific rewriting\n of the entire part based on genre\\-specific metadata\\. This is typically used to construct a table\n of contents or permalinks, but it can in principle arbitrarily rewrite the part\\. If it returns\n `none`, then no rewrite is performed\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"genrePart","kind":{"const":{"docs":"Operations carried out after `part`, when a part has metadata\\. It allows genre\\-specific rewriting\n of the entire part based on genre\\-specific metadata\\. This is typically used to construct a table\n of contents or permalinks, but it can in principle arbitrarily rewrite the part\\. If it returns\n `none`, then no rewrite is performed\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","genrePart"],"signature":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.PartMetadata → Doc.Part g → m (Option (Doc.Part g))"}}}}},"projFn":"Verso.Doc.Traverse.genrePart","type":{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":false,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Verso.Doc.Genre.PartMetadata (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The traversal of genre\\-specific block values\\. If it returns `none`, then no rewrite is performed\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"genreBlock","kind":{"const":{"docs":"The traversal of genre\\-specific block values\\. If it returns `none`, then no rewrite is performed\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","genreBlock"],"signature":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Block → Array (Doc.Block g) → m (Option (Doc.Block g))"}}}}},"projFn":"Verso.Doc.Traverse.genreBlock","type":{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Additional block\\-level values for documents written in the genre\\.\n ","isDef":false,"name":["Verso","Doc","Genre","Block"],"signature":"Verso.Doc.Genre.Block (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The traversal of genre\\-specific inline values\\. If it returns `none`, then no rewrite is performed\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"genreInline","kind":{"const":{"docs":"The traversal of genre\\-specific inline values\\. If it returns `none`, then no rewrite is performed\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","genreInline"],"signature":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Inline → Array (Doc.Inline g) → m (Option (Doc.Inline g))"}}}}},"projFn":"Verso.Doc.Traverse.genreInline","type":{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Additional inline\\-level values for documents written in the genre\\.\n ","isDef":false,"name":["Verso","Doc","Genre","Inline"],"signature":"Verso.Doc.Genre.Inline (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"}],"fieldNames":["part","block","inline","genrePart","genreBlock","genreInline"],"isClass":true,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Traverse","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.456","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.458","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"outParam","kind":{"const":{"docs":"Gadget for marking output parameters in type classes.\n\nFor example, the `Membership` class is defined as:\n```\nclass Membership (α : outParam (Type u)) (γ : Type v)\n```\nThis means that whenever a typeclass goal of the form `Membership ?α ?γ` comes\nup, Lean will wait to solve it until `?γ` is known, but then it will run\ntypeclass inference, and take the first solution it finds, for any value of `?α`,\nwhich thereby determines what `?α` should be.\n\nThis expresses that in a term like `a ∈ s`, `s` might be a `Set α` or\n`List α` or some other type with a membership operation, and in each case\nthe \"member\" type `α` is determined by looking at the container type.\n","isDef":false,"name":["outParam"],"signature":"outParam.{u} (α : Sort u) : Sort u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.Traverse","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.456","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.458","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"outParam","kind":{"const":{"docs":"Gadget for marking output parameters in type classes.\n\nFor example, the `Membership` class is defined as:\n```\nclass Membership (α : outParam (Type u)) (γ : Type v)\n```\nThis means that whenever a typeclass goal of the form `Membership ?α ?γ` comes\nup, Lean will wait to solve it until `?γ` is known, but then it will run\ntypeclass inference, and take the first solution it finds, for any value of `?α`,\nwhich thereby determines what `?α` should be.\n\nThis expresses that in a term like `a ∈ s`, `s` might be a `Set α` or\n`List α` or some other type with a membership operation, and in each case\nthe \"member\" type `α` is determined by looking at the container type.\n","isDef":false,"name":["outParam"],"signature":"outParam.{u} (α : Sort u) : Sort u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":119,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Genre"},{"text":"-"},{"text":"specific traversal"},{"text":"."}]},{"para":[{"text":"The traversal pass is where cross"},{"text":"-"},{"text":"references are resolved"},{"text":"."},{"text":" The traversal pass repeatedly applies a"},{"text":"\n"},{"text":"genre"},{"text":"-"},{"text":"specific stateful computation until a fixed point is reached, both with respect to the state"},{"text":"\n"},{"text":"and the document"},{"text":"."},{"text":" Traversal may update the state or rewrite parts of the document"},{"text":"."}]},{"para":[{"text":"The methods "},{"other":{"container":{"data":{"token":{"tok":{"content":"part","kind":"unknown"}}},"id":120,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"part"}]}},{"text":", "},{"other":{"container":{"data":{"token":{"tok":{"content":"block","kind":"unknown"}}},"id":121,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"block"}]}},{"text":", and "},{"other":{"container":{"data":{"token":{"tok":{"content":"inline","kind":{"const":{"docs":"`inline (f x)` is an indication to the compiler to inline the definition of `f`\nat the application site itself (by comparison to the `@[inline]` attribute,\nwhich applies to all applications of the function).\n","isDef":false,"name":["inline"],"signature":"inline.{u} {α : Sort u} (a : α) : α"}}}}},"id":122,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"inline"}]}},{"text":" provide effects to be carried out before traversing the"},{"text":"\n"},{"text":"given level of the AST, and "},{"other":{"container":{"data":{"token":{"tok":{"content":"part","kind":"unknown"}}},"id":123,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"part"}]}},{"text":" allows the part's metadata to be updated"},{"text":"."}]},{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"genrePart","kind":"unknown"}}},"id":124,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"genrePart"}]}},{"text":" is carried out after "},{"other":{"container":{"data":{"token":{"tok":{"content":"part","kind":"unknown"}}},"id":125,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"part"}]}},{"text":"."},{"text":" It allows genre"},{"text":"-"},{"text":"specific rewriting of the entire part based"},{"text":"\n"},{"text":"on genre"},{"text":"-"},{"text":"specific metadata"},{"text":"."},{"text":" This is typically used to construct a table of contents or permalinks,"},{"text":"\n"},{"text":"but it can in principle arbitrarily rewrite the part"},{"text":"."},{"text":" "},{"other":{"container":{"data":{"token":{"tok":{"content":"inPart","kind":"unknown"}}},"id":126,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"inPart"}]}},{"text":" is used to locally transform the"},{"text":"\n"},{"text":"genre's traversal context along the lines of "},{"other":{"container":{"data":{"token":{"tok":{"content":"withReader","kind":{"const":{"docs":"Locally modifies the reader monad's value while running an action.\n\nDuring the inner action `x`, reading the value returns `f` applied to the original value. After\ncontrol returns from `x`, the reader monad's value is restored.\n","isDef":false,"name":["MonadWithReader","withReader"],"signature":"MonadWithReader.withReader.{u, v} {ρ : outParam (Type u)} {m : Type u → Type v} [self : MonadWithReader ρ m]\n {α : Type u} (f : ρ → ρ) (x : m α) : m α"}}}}},"id":127,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"withReader"}]}},{"text":", and can be used to keep track of e"},{"text":"."},{"text":"g"},{"text":"."},{"text":" the"},{"text":"\n"},{"text":"current position in the table of contents"},{"text":"."}]},{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"genreBlock","kind":"unknown"}}},"id":128,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"genreBlock"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"genreInline","kind":"unknown"}}},"id":129,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"genreInline"}]}},{"text":" are invoked when traversal encounters "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"A custom block. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Block"],"signature":"Verso.Genre.Manual.Block : Type"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"other","kind":"unknown"}}}]}},"id":130,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Block.other"}]}},{"text":" and"},{"text":"\n"},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"A custom inline. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Inline"],"signature":"Verso.Genre.Manual.Inline : Type"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"other","kind":"unknown"}}}]}},"id":131,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Inline.other"}]}},{"text":"."},{"text":" It may rewrite them, or have state effects"},{"text":"."}]},{"other":{"container":{"data":"Instance Constructor","id":132,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Doc.Traverse.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","Traverse","mk"],"signature":"Verso.Doc.Traverse.mk {g : Doc.Genre} {m : outParam (Type → Type)}\n (part : [MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Part g → m (Option g.PartMetadata))\n (block : [MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Block g → m Unit)\n (inline : [MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Inline g → m Unit)\n (genrePart :\n [MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.PartMetadata → Doc.Part g → m (Option (Doc.Part g)))\n (genreBlock :\n [MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Block → Array (Doc.Block g) → m (Option (Doc.Block g)))\n (genreInline :\n [MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Inline → Array (Doc.Inline g) → m (Option (Doc.Inline g))) :\n Doc.Traverse g m"}}}}},null],"id":133,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Methods","id":134,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"part","kind":{"const":{"docs":"The effects carried out before traversing a `Part`\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","part"],"signature":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Part g → m (Option g.PartMetadata)"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":false,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Verso.Doc.Genre.PartMetadata (self : Doc.Genre) : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[]]]]],"id":135,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The effects carried out before traversing a "},{"other":{"container":{"data":{"token":{"tok":{"content":"Part","kind":"unknown"}}},"id":136,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Part"}]}},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"block","kind":{"const":{"docs":"The effects carried out before traversing a `Block`\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","block"],"signature":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Block g → m Unit"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}}]}},[null,[]]]]],"id":137,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The effects carried out before traversing a "},{"other":{"container":{"data":{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"A custom block. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Block"],"signature":"Verso.Genre.Manual.Block : Type"}}}}},"id":138,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Block"}]}},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"inline","kind":{"const":{"docs":"The effects carried out before traversing an `Inline`\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","inline"],"signature":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Inline g → m Unit"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}}]}},[null,[]]]]],"id":139,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The effects carried out before traversing an "},{"other":{"container":{"data":{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"A custom inline. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Inline"],"signature":"Verso.Genre.Manual.Inline : Type"}}}}},"id":140,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Inline"}]}},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"genrePart","kind":{"const":{"docs":"Operations carried out after `part`, when a part has metadata\\. It allows genre\\-specific rewriting\n of the entire part based on genre\\-specific metadata\\. This is typically used to construct a table\n of contents or permalinks, but it can in principle arbitrarily rewrite the part\\. If it returns\n `none`, then no rewrite is performed\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","genrePart"],"signature":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.PartMetadata → Doc.Part g → m (Option (Doc.Part g))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"The metadata that may be associated with each `Part` \\(e\\.g\\. author, publication date,\n cross\\-referencing identifier\\)\\.\n ","isDef":false,"name":["Verso","Doc","Genre","PartMetadata"],"signature":"Verso.Doc.Genre.PartMetadata (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[]]]]],"id":141,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Operations carried out after "},{"other":{"container":{"data":{"token":{"tok":{"content":"part","kind":{"var":{"name":"_uniq.510","type":"[MonadReader g.TraverseContext m] → [MonadState g.TraverseState m] → Doc.Part g → m (Option g.PartMetadata)"}}}}},"id":142,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"part"}]}},{"text":", when a part has metadata"},{"text":"."},{"text":" It allows genre"},{"text":"-"},{"text":"specific rewriting"},{"text":"\n"},{"text":"of the entire part based on genre"},{"text":"-"},{"text":"specific metadata"},{"text":"."},{"text":" This is typically used to construct a table"},{"text":"\n"},{"text":"of contents or permalinks, but it can in principle arbitrarily rewrite the part"},{"text":"."},{"text":" If it returns"},{"text":"\n"},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":143,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", then no rewrite is performed"},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"genreBlock","kind":{"const":{"docs":"The traversal of genre\\-specific block values\\. If it returns `none`, then no rewrite is performed\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","genreBlock"],"signature":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Block → Array (Doc.Block g) → m (Option (Doc.Block g))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"Block","kind":{"const":{"docs":"Additional block\\-level values for documents written in the genre\\.\n ","isDef":false,"name":["Verso","Doc","Genre","Block"],"signature":"Verso.Doc.Genre.Block (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[]]]]],"id":144,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The traversal of genre"},{"text":"-"},{"text":"specific block values"},{"text":"."},{"text":" If it returns "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":145,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", then no rewrite is performed"},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"genreInline","kind":{"const":{"docs":"The traversal of genre\\-specific inline values\\. If it returns `none`, then no rewrite is performed\\.\n ","isDef":true,"name":["Verso","Doc","Traverse","genreInline"],"signature":"[MonadReader g.TraverseContext m] →\n [MonadState g.TraverseState m] → g.Inline → Array (Doc.Inline g) → m (Option (Doc.Inline g))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadReader","kind":{"const":{"docs":"Reader monads provide the ability to implicitly thread a value through a computation. The value can\nbe read, but not written. A `MonadWithReader ρ` instance additionally allows the value to be locally\noverridden for a sub-computation.\n\nIn this class, `ρ` is an `outParam`, which means that it is inferred from `m`. `MonadReaderOf ρ`\nprovides the same operations, but allows `ρ` to influence instance synthesis.\n","isDef":false,"name":["MonadReader"],"signature":"MonadReader.{u, v} (ρ : outParam (Type u)) (m : Type u → Type v) : Type v"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"MonadState","kind":{"const":{"docs":"State monads provide a value of a given type (the _state_) that can be retrieved or replaced.\nInstances may implement these operations by passing state values around, by using a mutable\nreference cell (e.g. `ST.Ref σ`), or in other ways.\n\nIn this class, `σ` is an `outParam`, which means that it is inferred from `m`. `MonadStateOf σ`\nprovides the same operations, but allows `σ` to influence instance synthesis.\n\nThe mutable state of a state monad is visible between multiple `do`-blocks or functions, unlike\n[local mutable state](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation-let-mut) in `do`-notation.\n","isDef":false,"name":["MonadState"],"signature":"MonadState.{u, v} (σ : outParam (Type u)) (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":"The mutable state used in the genre's traversal pass\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseState"],"signature":"Verso.Doc.Genre.TraverseState (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"Inline","kind":{"const":{"docs":"Additional inline\\-level values for documents written in the genre\\.\n ","isDef":false,"name":["Verso","Doc","Genre","Inline"],"signature":"Verso.Doc.Genre.Inline (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.254","type":"outParam (Type → Type)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.253","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[]]]]],"id":146,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The traversal of genre"},{"text":"-"},{"text":"specific inline values"},{"text":"."},{"text":" If it returns "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":147,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", then no rewrite is performed"},{"text":"."}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.TraversePart",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Doc.TraversePart.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","TraversePart","mk"],"signature":"Verso.Doc.TraversePart.mk {g : Doc.Genre} (inPart : Doc.Part g → g.TraverseContext → g.TraverseContext) :\n Doc.TraversePart g"}}}}},"name":"Verso.Doc.TraversePart.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.TraversePart.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.589","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"inPart","kind":{"var":{"name":"_uniq.594","type":"Doc.Part g → g.TraverseContext → g.TraverseContext"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.589","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.589","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.589","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.TraversePart","kind":{"const":{"docs":"Specifies how to modify the context while traversing the contents of a given part\\.\n","isDef":false,"name":["Verso","Doc","TraversePart"],"signature":"Verso.Doc.TraversePart (g : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.589","type":"Doc.Genre"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"How to modify the context while traversing the contents of a given part\\. This is applied after\n `part` and `genrePart` have rewritten the text, if applicable\\.\n\nIt is also used during HTML generation\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"inPart","kind":{"const":{"docs":"How to modify the context while traversing the contents of a given part\\. This is applied after\n `part` and `genrePart` have rewritten the text, if applicable\\.\n\nIt is also used during HTML generation\\.\n ","isDef":true,"name":["Verso","Doc","TraversePart","inPart"],"signature":"Doc.Part g → g.TraverseContext → g.TraverseContext"}}}}},"projFn":"Verso.Doc.TraversePart.inPart","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.583","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.583","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.583","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["inPart"],"isClass":true,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.TraversePart","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.598","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.TraversePart","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.598","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":148,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Specifies how to modify the context while traversing the contents of a given part"},{"text":"."}]},{"other":{"container":{"data":"Instance Constructor","id":149,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Doc.TraversePart.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","TraversePart","mk"],"signature":"Verso.Doc.TraversePart.mk {g : Doc.Genre} (inPart : Doc.Part g → g.TraverseContext → g.TraverseContext) :\n Doc.TraversePart g"}}}}},null],"id":150,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Methods","id":151,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"inPart","kind":{"const":{"docs":"How to modify the context while traversing the contents of a given part\\. This is applied after\n `part` and `genrePart` have rewritten the text, if applicable\\.\n\nIt is also used during HTML generation\\.\n ","isDef":true,"name":["Verso","Doc","TraversePart","inPart"],"signature":"Doc.Part g → g.TraverseContext → g.TraverseContext"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Doc.Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.583","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.583","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.583","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}}]}},[null,[]]]]],"id":152,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to modify the context while traversing the contents of a given part"},{"text":"."},{"text":" This is applied after"},{"text":"\n"},{"other":{"container":{"data":{"token":{"tok":{"content":"part","kind":"unknown"}}},"id":153,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"part"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"genrePart","kind":"unknown"}}},"id":154,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"genrePart"}]}},{"text":" have rewritten the text, if applicable"},{"text":"."}]},{"para":[{"text":"It is also used during HTML generation"},{"text":"."}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Doc.TraverseBlock",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Doc.TraverseBlock.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","TraverseBlock","mk"],"signature":"Verso.Doc.TraverseBlock.mk {g : Doc.Genre} (inBlock : Doc.Block g → g.TraverseContext → g.TraverseContext) :\n Doc.TraverseBlock g"}}}}},"name":"Verso.Doc.TraverseBlock.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.TraverseBlock.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.637","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"inBlock","kind":{"var":{"name":"_uniq.642","type":"Doc.Block g → g.TraverseContext → g.TraverseContext"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.637","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.637","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.637","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Doc.TraverseBlock","kind":{"const":{"docs":"Specifies how to modify the context while traversing the contents of a given block\\.\n","isDef":false,"name":["Verso","Doc","TraverseBlock"],"signature":"Verso.Doc.TraverseBlock (g : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.637","type":"Doc.Genre"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"How to modify the context while traversing a given block\\.\n\nIt is also used during HTML generation\\.\n ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"inBlock","kind":{"const":{"docs":"How to modify the context while traversing a given block\\.\n\nIt is also used during HTML generation\\.\n ","isDef":true,"name":["Verso","Doc","TraverseBlock","inBlock"],"signature":"Doc.Block g → g.TraverseContext → g.TraverseContext"}}}}},"projFn":"Verso.Doc.TraverseBlock.inBlock","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.631","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.631","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.631","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["inBlock"],"isClass":true,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.TraverseBlock","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.646","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Doc.TraverseBlock","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.646","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":155,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Specifies how to modify the context while traversing the contents of a given block"},{"text":"."}]},{"other":{"container":{"data":"Instance Constructor","id":156,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Doc.TraverseBlock.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","TraverseBlock","mk"],"signature":"Verso.Doc.TraverseBlock.mk {g : Doc.Genre} (inBlock : Doc.Block g → g.TraverseContext → g.TraverseContext) :\n Doc.TraverseBlock g"}}}}},null],"id":157,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Methods","id":158,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"inBlock","kind":{"const":{"docs":"How to modify the context while traversing a given block\\.\n\nIt is also used during HTML generation\\.\n ","isDef":true,"name":["Verso","Doc","TraverseBlock","inBlock"],"signature":"Doc.Block g → g.TraverseContext → g.TraverseContext"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.631","type":"Doc.Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.631","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"g","kind":{"var":{"name":"_uniq.631","type":"Doc.Genre"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"TraverseContext","kind":{"const":{"docs":"The reader\\-style data used in the genre's traversal pass\\. Instances of `TraversePart` and\n `TraverseBlock` for a genre specify how this is updated while traversing parts and blocks,\n respectively\\.\n ","isDef":false,"name":["Verso","Doc","Genre","TraverseContext"],"signature":"Verso.Doc.Genre.TraverseContext (self : Doc.Genre) : Type"}}}}}]}},[null,[]]]]],"id":159,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to modify the context while traversing a given block"},{"text":"."}]},{"para":[{"text":"It is also used during HTML generation"},{"text":"."}]}]}}]}}]}}]}],"metadata":{"assignedNumber":3,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":109,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"traversal"}}},"subParts":[],"title":[{"text":"Traversal"}],"titleString":"Traversal"},{"content":[{"para":[{"text":"Following traversal, the readable version of the document is generated."},{"linebreak":"\n"},{"text":"This may be in any format; each "},{"other":{"container":{"data":["genre","/home/runner/work/verso/verso/doc/UsersGuide/Elab.lean:101:32",null],"id":161,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"genre"}]}},{"text":" defines its supported formats."}]},{"para":[{"text":"Additionally, genres that emit HTML may generate a serialized version of their cross-reference database."},{"linebreak":"\n"},{"text":"This can be used to automatically maintain the links that implement cross-references between Verso documents: if content moves, rebuilding the linking document is sufficient to fix the link."},{"linebreak":"\n"}]}],"metadata":{"assignedNumber":4,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":160,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"output-gen"}}},"subParts":[],"title":[{"text":"Output Generation"}],"titleString":"Output Generation"}],"title":[{"text":"Building Documents"}],"titleString":"Building Documents"},{"content":[{"para":[{"text":"Verso's markup language features four extension points:"}]},{"ul":[{"contents":[{"para":[{"other":{"container":{"data":["role","/home/runner/work/verso/verso/doc/UsersGuide/Extensions.lean:18:3",null],"id":163,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"Roles"}]}}]}]},{"contents":[{"para":[{"other":{"container":{"data":["directive","/home/runner/work/verso/verso/doc/UsersGuide/Extensions.lean:19:3",null],"id":164,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"Directives"}]}}]}]},{"contents":[{"para":[{"other":{"container":{"data":["code block","/home/runner/work/verso/verso/doc/UsersGuide/Extensions.lean:20:3",null],"id":165,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"Code blocks"}]}}]}]},{"contents":[{"para":[{"other":{"container":{"data":["command","/home/runner/work/verso/verso/doc/UsersGuide/Extensions.lean:21:3",null],"id":166,"name":"Verso.Genre.Manual.tech"},"content":[{"text":"Commands"}]}}]}]}]},{"para":[{"text":"These can be used to extend Verso to support new documentation features."}]}],"metadata":{"assignedNumber":4,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"never","htmlToc":true,"id":162,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"extensions"}}},"subParts":[{"content":[{"para":[{"text":"All four extension points share a common syntax."},{"linebreak":"\n"},{"text":"They are invoked by name, with a sequence of arguments."},{"linebreak":"\n"},{"text":"These arguments may be positional or by name, and their values may be identifiers, string literals, or numbers."},{"linebreak":"\n"},{"text":"Boolean flags may be passed by preceding their name with "},{"code":"-"},{"text":" or "},{"code":"+"},{"text":" for "},{"other":{"container":{"data":[{"token":{"tok":{"content":"false","kind":{"const":{"docs":"The Boolean value `false`, not to be confused with the proposition `False`. ","isDef":false,"name":["Bool","false"],"signature":"Bool.false : Bool"}}}}},[]],"id":168,"name":"Verso.Genre.Manual.InlineLean.Inline.lean"},"content":[{"code":"false"}]}},{"text":" or "},{"other":{"container":{"data":[{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},[]],"id":169,"name":"Verso.Genre.Manual.InlineLean.Inline.lean"},"content":[{"code":"true"}]}},{"text":", respectively."}]},{"concat":[{"other":{"container":{"data":null,"id":170,"name":"Verso.Genre.Manual.Block.paragraph","properties":{}},"content":[{"para":[{"text":"In this example, the directive "},{"code":"syntax"},{"text":" is invoked with the positional argument "},{"code":"term"},{"text":" and the named argument "},{"code":"title"},{"text":" set to "},{"code":"\"Example\""},{"text":"."},{"linebreak":"\n"},{"text":"The flag "},{"code":"check"},{"text":" is set to "},{"code":"false"},{"text":"."},{"linebreak":"\n"},{"text":"It contains a descriptive paragraph and the code block "},{"code":"grammar"},{"text":", which is invoked with no arguments:"}]},{"code":":::syntax term (title := example) -check\nThis is an example grammar:\n```grammar\nterm ::= term \"<+-+>\" term\n```\n:::\n"}]}}]},{"concat":[{"other":{"container":{"data":null,"id":171,"name":"Verso.Genre.Manual.Block.paragraph","properties":{}},"content":[{"para":[{"text":"More formally, an invocation of an extension should match this grammar:"}]},{"code":"CALL := IDENT ARG*\nARG := VAL | \"(\" IDENT \":=\" VAL \")\" | \"+\" IDENT | \"-\" IDENT\nVAL := IDENT | STRING | NUM\n"},{"para":[{"text":"A "},{"code":"CALL"},{"text":" may occur after an opening fence on a code block."},{"linebreak":"\n"},{"text":"It is mandatory after the opening colons of a directive, in the opening curly braces of a role, or in a command."}]}]}}]}],"metadata":{"assignedNumber":1,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":167,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"extension-syntax"}}},"subParts":[],"title":[{"text":"Syntax"}],"titleString":"Syntax"},{"content":[{"para":[{"text":"Each kind of extension has a table that maps names to expanders."},{"linebreak":"\n"},{"text":"An "},{"other":{"container":{"data":["expander","expander"],"id":173,"name":"Verso.Genre.Manual.deftech"},"content":[{"emph":[{"text":"expander"}]}]}},{"text":" converts Verso's syntax to Lean terms."},{"linebreak":"\n"},{"text":"When the elaborator encounters a code block, role, directive, or command invocation, it resolves the name and looks up an expander in the table."},{"linebreak":"\n"},{"text":"Expanders are attempted until one of them either throws an error or succeeds."},{"linebreak":"\n"},{"text":"Expanders use the monad "},{"other":{"container":{"data":{"token":{"tok":{"content":"DocElabM","kind":{"const":{"docs":"Text elaboration monad\\.\n\nThis monad can produce content, but it can't modify the structure of the surrounding document\\. It\ncan observe this structure, however\\.\n\nThis means it can modify the `DocElabM.State`, but it can only read from the\n`PartElabM.State`\\.\n","isDef":false,"name":["Verso","Doc","Elab","DocElabM"],"signature":"Verso.Doc.Elab.DocElabM (α : Type) : Type"}}}}},"id":174,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"DocElabM"}]}},{"text":", which is an extension of Lean's term elaboration monad "},{"other":{"container":{"data":{"token":{"tok":{"content":"TermElabM","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Elab","Term","TermElabM"],"signature":"Lean.Elab.Term.TermElabM (α : Type) : Type"}}}}},"id":175,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"TermElabM"}]}},{"text":" with document-specific features."},{"linebreak":"\n"},{"text":"Expanders first "},{"other":{"container":{"data":{"canonicalName":"ArgParse","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Extensions/#ArgParse"},"id":627,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"parse"}]}},{"text":" their arguments into a suitable configuration type, typically via a "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgs","kind":{"const":{"docs":"A canonical way to convert a sequence of Verso arguments into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgs"],"signature":"Verso.ArgParse.FromArgs (α : Type) (m : Type → Type) : Type 1"}}}}},"id":177,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"FromArgs"}]}},{"text":" instance, after which they return Lean syntax."}]},{"para":[{"text":"There are two ways to associate an expander with a name: the "},{"code":"@[code_block]"},{"text":", "},{"code":"@[role]"},{"text":", "},{"code":"@[directive]"},{"text":", and "},{"code":"@[block_command]"},{"text":" attributes (preferred) or the "},{"code":"@[code_block_expander]"},{"text":", "},{"code":"@[role_expander]"},{"text":", and "},{"code":"@[directive_expander]"},{"text":" attributes."},{"linebreak":"\n"},{"text":"Using the former attributes results in an expander that invokes the argument parser automatically, and they enable Verso to automatically compute usage information from a "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgs","kind":{"const":{"docs":"A canonical way to convert a sequence of Verso arguments into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgs"],"signature":"Verso.ArgParse.FromArgs (α : Type) (m : Type → Type) : Type 1"}}}}},"id":178,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"FromArgs"}]}},{"text":" instance."},{"linebreak":"\n"},{"text":"The latter are lower-level, and require manual parsing of arguments."}]}],"metadata":{"assignedNumber":2,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":172,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"elab-extensions"}}},"subParts":[{"content":[{"para":[{"text":"This grammar is fairly restrictive, so each extension is responsible for parsing their arguments in order to afford sufficient flexibility."},{"linebreak":"\n"},{"text":"Arguments are parsed via instances of "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgs","kind":{"const":{"docs":"A canonical way to convert a sequence of Verso arguments into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgs"],"signature":"Verso.ArgParse.FromArgs (α : Type) (m : Type → Type) : Type 1"}}}}},"id":180,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"FromArgs"}]}},{"text":":"}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.FromArgs",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.ArgParse.FromArgs.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","FromArgs","mk"],"signature":"Verso.ArgParse.FromArgs.mk {α : Type} {m : Type → Type} (fromArgs : ArgParse m α) : ArgParse.FromArgs α m"}}}}},"name":"Verso.ArgParse.FromArgs.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgs.mk","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.41","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.43","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"fromArgs","kind":{"var":{"name":"_uniq.46","type":"ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.43","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.41","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse.FromArgs","kind":{"const":{"docs":"A canonical way to convert a sequence of Verso arguments into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgs"],"signature":"Verso.ArgParse.FromArgs (α : Type) (m : Type → Type) : Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.41","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.43","type":"Type → Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"Converts a sequence of arguments into a value. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"fromArgs","kind":{"const":{"docs":"Converts a sequence of arguments into a value. ","isDef":true,"name":["Verso","ArgParse","FromArgs","fromArgs"],"signature":"ArgParse m α"}}}}},"projFn":"Verso.ArgParse.FromArgs.fromArgs","type":{"seq":{"highlights":[{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.37","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.36","type":"Type"}}}}}]}},"visibility":"public"}],"fieldNames":["fromArgs"],"isClass":true,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgs","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.49","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.51","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgs","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.49","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.51","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":181,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A canonical way to convert a sequence of Verso arguments into a given type."}]},{"other":{"container":{"data":"Instance Constructor","id":182,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgs.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","FromArgs","mk"],"signature":"Verso.ArgParse.FromArgs.mk {α : Type} {m : Type → Type} (fromArgs : ArgParse m α) : ArgParse.FromArgs α m"}}}}},null],"id":183,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Methods","id":184,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"fromArgs","kind":{"const":{"docs":"Converts a sequence of arguments into a value. ","isDef":true,"name":["Verso","ArgParse","FromArgs","fromArgs"],"signature":"ArgParse m α"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.37","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.36","type":"Type"}}}}}]}},[null,[]]]]],"id":185,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Converts a sequence of arguments into a value."}]}]}}]}}]}}]},{"para":[{"text":"Implementations of "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgs.fromArgs","kind":{"const":{"docs":"Converts a sequence of arguments into a value. ","isDef":false,"name":["Verso","ArgParse","FromArgs","fromArgs"],"signature":"Verso.ArgParse.FromArgs.fromArgs {α : Type} {m : Type → Type} [self : ArgParse.FromArgs α m] : ArgParse m α"}}}}},"id":186,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"FromArgs.fromArgs"}]}},{"text":" specify parsers written using "},{"other":{"container":{"data":{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},"id":187,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"ArgParse"}]}},{"text":":"}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse",[{"inductive":{"constructors":[{"docstring":"Fails with the provided error message.\n","hlName":{"token":{"tok":{"content":"fail","kind":{"const":{"docs":"Fails with the provided error message.\n","isDef":false,"name":["Verso","ArgParse","fail"],"signature":"Verso.ArgParse.fail {m : Type → Type} {α : Type} (stx? : Option Lean.Syntax) (message? : Option ArgParse.SigDoc) :\n ArgParse m α"}}}}},"name":"Verso.ArgParse.fail","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"fail","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.74","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.75","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"stx?","kind":{"var":{"name":"_uniq.76","type":"Option Lean.Syntax"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Syntax","kind":{"const":{"docs":"Lean syntax trees.\n\nSyntax trees are used pervasively throughout Lean: they are produced by the parser, transformed by\nthe macro expander, and elaborated. They are also produced by the delaborator and presented to\nusers.\n","isDef":false,"name":["Lean","Syntax"],"signature":"Lean.Syntax : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"message?","kind":{"var":{"name":"_uniq.77","type":"Option ArgParse.SigDoc"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.74","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.75","type":"Type"}}}}}]}}},{"docstring":"Returns a value without parsing any arguments.\n","hlName":{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Returns a value without parsing any arguments.\n","isDef":false,"name":["Verso","ArgParse","pure"],"signature":"Verso.ArgParse.pure {m : Type → Type} {α : Type} (val : α) : ArgParse m α"}}}}},"name":"Verso.ArgParse.pure","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"pure","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.81","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.82","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.83","type":"α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.82","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.81","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.82","type":"Type"}}}}}]}}},{"docstring":"Provides an argument value by lifting an action from the underlying monad.\n","hlName":{"token":{"tok":{"content":"lift","kind":{"const":{"docs":"Provides an argument value by lifting an action from the underlying monad.\n","isDef":false,"name":["Verso","ArgParse","lift"],"signature":"Verso.ArgParse.lift {m : Type → Type} {α : Type} (desc : String) (act : m α) : ArgParse m α"}}}}},"name":"Verso.ArgParse.lift","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"lift","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.87","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.88","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"desc","kind":{"var":{"name":"_uniq.89","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"act","kind":{"var":{"name":"_uniq.90","type":"m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.87","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.88","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.87","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.88","type":"Type"}}}}}]}}},{"docstring":"Matches a positional argument.\n","hlName":{"token":{"tok":{"content":"positional","kind":{"const":{"docs":"Matches a positional argument.\n","isDef":false,"name":["Verso","ArgParse","positional"],"signature":"Verso.ArgParse.positional {m : Type → Type} {α : Type} (nameHint : Lean.Name) (val : ArgParse.ValDesc m α)\n (doc? : Option ArgParse.SigDoc := none) : ArgParse m α"}}}}},"name":"Verso.ArgParse.positional","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"positional","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.94","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.95","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"nameHint","kind":{"var":{"name":"_uniq.96","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.99","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.94","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.95","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.101","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.94","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.95","type":"Type"}}}}}]}}},{"docstring":"Matches an argument with the provided name.\n","hlName":{"token":{"tok":{"content":"named","kind":{"const":{"docs":"Matches an argument with the provided name.\n","isDef":false,"name":["Verso","ArgParse","named"],"signature":"Verso.ArgParse.named {m : Type → Type} {α : Type} (name : Lean.Name) (val : ArgParse.ValDesc m α) (optional : Bool)\n (doc? : Option ArgParse.SigDoc := none) : ArgParse m (if optional = true then Option α else α)"}}}}},"name":"Verso.ArgParse.named","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"named","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.105","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.107","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.110","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.105","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.111","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.113","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.105","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"token":{"tok":{"content":"if","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.111","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=","kind":{"const":{"docs":"The equality relation. It has one introduction rule, `Eq.refl`.\nWe use `a = b` as notation for `Eq a b`.\nA fundamental property of equality is that it is an equivalence relation.\n```\nvariable (α : Type) (a b c d : α)\nvariable (hab : a = b) (hcb : c = b) (hcd : c = d)\n\nexample : a = d :=\n Eq.trans (Eq.trans hab (Eq.symm hcb)) hcd\n```\nEquality is much more than an equivalence relation, however. It has the important property that every assertion\nrespects the equivalence, in the sense that we can substitute equal expressions without changing the truth value.\nThat is, given `h1 : a = b` and `h2 : p a`, we can construct a proof for `p b` using substitution: `Eq.subst h1 h2`.\nExample:\n```\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n Eq.subst h1 h2\n\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n h1 ▸ h2\n```\nThe triangle in the second presentation is a macro built on top of `Eq.subst` and `Eq.symm`, and you can enter it by typing `\\t`.\nFor more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `=` in identifiers is `eq`.","isDef":false,"name":["Eq"],"signature":"Eq.{u_1} {α : Sort u_1} : α → α → Prop"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"then","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"else","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}}]}}},{"docstring":"Matches any named argument.\n","hlName":{"token":{"tok":{"content":"anyNamed","kind":{"const":{"docs":"Matches any named argument.\n","isDef":false,"name":["Verso","ArgParse","anyNamed"],"signature":"Verso.ArgParse.anyNamed {m : Type → Type} {α : Type} (name : Lean.Name) (val : ArgParse.ValDesc m α)\n (doc? : Option ArgParse.SigDoc := none) : ArgParse m (Lean.Ident × α)"}}}}},"name":"Verso.ArgParse.anyNamed","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"anyNamed","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.117","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.118","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.119","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.122","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.117","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.118","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.124","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.117","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"Lean.Ident","kind":{"const":{"docs":"Syntax that represents an identifier.\n","isDef":false,"name":["Lean","Syntax","Ident"],"signature":"Lean.Syntax.Ident : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.118","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}}]}}},{"docstring":"Matches a flag with the provided name.\n","hlName":{"token":{"tok":{"content":"flag","kind":{"const":{"docs":"Matches a flag with the provided name.\n","isDef":false,"name":["Verso","ArgParse","flag"],"signature":"Verso.ArgParse.flag {m : Type → Type} (name : Lean.Name) (default : Bool) (doc? : Option ArgParse.SigDoc := none) :\n ArgParse m Bool"}}}}},"name":"Verso.ArgParse.flag","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"flag","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.128","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.129","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.130","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.132","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.128","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}}]}}},{"docstring":"Matches a flag with the provided name, deriving a default value from the monad\n","hlName":{"token":{"tok":{"content":"flagM","kind":{"const":{"docs":"Matches a flag with the provided name, deriving a default value from the monad\n","isDef":false,"name":["Verso","ArgParse","flagM"],"signature":"Verso.ArgParse.flagM {m : Type → Type} (name : Lean.Name) (default : m Bool) (doc? : Option ArgParse.SigDoc := none) :\n ArgParse m Bool"}}}}},"name":"Verso.ArgParse.flagM","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"flagM","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.136","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.137","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.138","type":"m Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.136","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.140","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.136","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}}]}}},{"docstring":"No further arguments are allowed.\n","hlName":{"token":{"tok":{"content":"done","kind":{"const":{"docs":"No further arguments are allowed.\n","isDef":false,"name":["Verso","ArgParse","done"],"signature":"Verso.ArgParse.done {m : Type → Type} : ArgParse m Unit"}}}}},"name":"Verso.ArgParse.done","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"done","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.144","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.144","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}}]}}},{"docstring":"Error recovery.\n","hlName":{"token":{"tok":{"content":"orElse","kind":{"const":{"docs":"Error recovery.\n","isDef":false,"name":["Verso","ArgParse","orElse"],"signature":"Verso.ArgParse.orElse {m : Type → Type} {α : Type} (p1 : ArgParse m α) (p2 : Unit → ArgParse m α) : ArgParse m α"}}}}},"name":"Verso.ArgParse.orElse","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"orElse","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p1","kind":{"var":{"name":"_uniq.152","type":"ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p2","kind":{"var":{"name":"_uniq.156","type":"Unit → ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}}]}}},{"docstring":"The sequencing operation of an applicative functor.\n","hlName":{"token":{"tok":{"content":"seq","kind":{"const":{"docs":"The sequencing operation of an applicative functor.\n","isDef":false,"name":["Verso","ArgParse","seq"],"signature":"Verso.ArgParse.seq {m : Type → Type} {α β : Type} (p1 : ArgParse m (α → β)) (p2 : Unit → ArgParse m α) : ArgParse m β"}}}}},"name":"Verso.ArgParse.seq","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"seq","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.161","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"β","kind":{"var":{"name":"_uniq.162","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p1","kind":{"var":{"name":"_uniq.166","type":"ArgParse m (α → β)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.161","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"β","kind":{"var":{"name":"_uniq.162","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p2","kind":{"var":{"name":"_uniq.170","type":"Unit → ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.161","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"β","kind":{"var":{"name":"_uniq.162","type":"Type"}}}}}]}}},{"docstring":"Zero or more repetitions.\n","hlName":{"token":{"tok":{"content":"many","kind":{"const":{"docs":"Zero or more repetitions.\n","isDef":false,"name":["Verso","ArgParse","many"],"signature":"Verso.ArgParse.many {m : Type → Type} {α : Type} : ArgParse m α → ArgParse m (List α)"}}}}},"name":"Verso.ArgParse.many","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"many","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.174","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.175","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.174","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.175","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.174","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.175","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}}},{"docstring":"Returns all remaining arguments. This is useful for consuming some, then forwarding the rest. ","hlName":{"token":{"tok":{"content":"remaining","kind":{"const":{"docs":"Returns all remaining arguments. This is useful for consuming some, then forwarding the rest. ","isDef":false,"name":["Verso","ArgParse","remaining"],"signature":"Verso.ArgParse.remaining {m : Type → Type} : ArgParse m (Array Doc.Arg)"}}}}},"name":"Verso.ArgParse.remaining","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"remaining","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.183","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.183","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Arg","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","Arg"],"signature":"Verso.Doc.Arg : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}}}],"numArgs":2,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.189","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.189","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type 1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":188,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A parser for arguments in some underlying monad."}]},{"other":{"container":{"data":"Constructors","id":189,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"fail","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.74","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.75","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"stx?","kind":{"var":{"name":"_uniq.76","type":"Option Lean.Syntax"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Syntax","kind":{"const":{"docs":"Lean syntax trees.\n\nSyntax trees are used pervasively throughout Lean: they are produced by the parser, transformed by\nthe macro expander, and elaborated. They are also produced by the delaborator and presented to\nusers.\n","isDef":false,"name":["Lean","Syntax"],"signature":"Lean.Syntax : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"message?","kind":{"var":{"name":"_uniq.77","type":"Option ArgParse.SigDoc"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.74","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.75","type":"Type"}}}}}]}},"id":190,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Fails with the provided error message."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"pure","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.81","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.82","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.83","type":"α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.82","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.81","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.82","type":"Type"}}}}}]}},"id":191,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Returns a value without parsing any arguments."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"lift","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.87","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.88","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"desc","kind":{"var":{"name":"_uniq.89","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"act","kind":{"var":{"name":"_uniq.90","type":"m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.87","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.88","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.87","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.88","type":"Type"}}}}}]}},"id":192,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Provides an argument value by lifting an action from the underlying monad."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"positional","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.94","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.95","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"nameHint","kind":{"var":{"name":"_uniq.96","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.99","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.94","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.95","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.101","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.94","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.95","type":"Type"}}}}}]}},"id":193,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Matches a positional argument."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"named","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.105","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.107","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.110","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.105","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.111","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.113","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.105","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"token":{"tok":{"content":"if","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.111","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=","kind":{"const":{"docs":"The equality relation. It has one introduction rule, `Eq.refl`.\nWe use `a = b` as notation for `Eq a b`.\nA fundamental property of equality is that it is an equivalence relation.\n```\nvariable (α : Type) (a b c d : α)\nvariable (hab : a = b) (hcb : c = b) (hcd : c = d)\n\nexample : a = d :=\n Eq.trans (Eq.trans hab (Eq.symm hcb)) hcd\n```\nEquality is much more than an equivalence relation, however. It has the important property that every assertion\nrespects the equivalence, in the sense that we can substitute equal expressions without changing the truth value.\nThat is, given `h1 : a = b` and `h2 : p a`, we can construct a proof for `p b` using substitution: `Eq.subst h1 h2`.\nExample:\n```\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n Eq.subst h1 h2\n\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n h1 ▸ h2\n```\nThe triangle in the second presentation is a macro built on top of `Eq.subst` and `Eq.symm`, and you can enter it by typing `\\t`.\nFor more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `=` in identifiers is `eq`.","isDef":false,"name":["Eq"],"signature":"Eq.{u_1} {α : Sort u_1} : α → α → Prop"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"then","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"else","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.106","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}}]}},"id":194,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Matches an argument with the provided name."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"anyNamed","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.117","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.118","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.119","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.122","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.117","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.118","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.124","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.117","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"Lean.Ident","kind":{"const":{"docs":"Syntax that represents an identifier.\n","isDef":false,"name":["Lean","Syntax","Ident"],"signature":"Lean.Syntax.Ident : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.118","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}}]}},"id":195,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Matches any named argument."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"flag","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.128","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.129","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.130","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.132","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.128","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}}]}},"id":196,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Matches a flag with the provided name."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"flagM","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.136","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.137","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.138","type":"m Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.136","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.140","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.136","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}}]}},"id":197,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Matches a flag with the provided name, deriving a default value from the monad"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"done","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.144","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.144","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}}]}},"id":198,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"No further arguments are allowed."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"orElse","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p1","kind":{"var":{"name":"_uniq.152","type":"ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p2","kind":{"var":{"name":"_uniq.156","type":"Unit → ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.148","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.149","type":"Type"}}}}}]}},"id":199,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Error recovery."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"seq","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.161","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"β","kind":{"var":{"name":"_uniq.162","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p1","kind":{"var":{"name":"_uniq.166","type":"ArgParse m (α → β)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.161","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"β","kind":{"var":{"name":"_uniq.162","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"p2","kind":{"var":{"name":"_uniq.170","type":"Unit → ArgParse m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Unit","kind":{"const":{"docs":"The canonical type with one element. This element is written `()`.\n\n`Unit` has a number of uses:\n* It can be used to model control flow that returns from a function call without providing other\n information.\n* Monadic actions that return `Unit` have side effects without computing values.\n* In polymorphic types, it can be used to indicate that no data is to be stored in a particular\n field.\n","isDef":false,"name":["Unit"],"signature":"Unit : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.161","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.160","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"β","kind":{"var":{"name":"_uniq.162","type":"Type"}}}}}]}},"id":200,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"The sequencing operation of an applicative functor."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"many","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.174","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.175","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.174","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.175","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.174","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.175","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"id":201,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Zero or more repetitions."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"remaining","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.183","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.183","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.Arg","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","Arg"],"signature":"Verso.Doc.Arg : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"id":202,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Returns all remaining arguments. This is useful for consuming some, then forwarding the rest."}]}]}}]}}]}}]},{"para":[{"text":"Individual argument values are matched using "},{"other":{"container":{"data":{"token":{"tok":{"content":"ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},"id":203,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"ValDesc"}]}},{"text":":"}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.ValDesc",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.ArgParse.ValDesc.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","ValDesc","mk"],"signature":"Verso.ArgParse.ValDesc.mk {m : Type → Type} {α : Type} (description : ArgParse.SigDoc) (signature : ArgParse.CanMatch)\n (get : Doc.ArgVal → m α) : ArgParse.ValDesc m α"}}}}},"name":"Verso.ArgParse.ValDesc.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.ValDesc.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.282","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.283","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"description","kind":{"var":{"name":"_uniq.284","type":"ArgParse.SigDoc"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"signature","kind":{"var":{"name":"_uniq.285","type":"ArgParse.CanMatch"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.CanMatch","kind":{"const":{"docs":"Documents which kinds of values a `ValDesc` might match.\n\nThese are typically constructed using `CanMatch.Ident`, `CanMatch.String`, `CanMatch.Num`, and the\n`Union CanMatch` instance.\n","isDef":false,"name":["Verso","ArgParse","CanMatch"],"signature":"Verso.ArgParse.CanMatch : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"get","kind":{"var":{"name":"_uniq.287","type":"Doc.ArgVal → m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Doc.ArgVal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","ArgVal"],"signature":"Verso.Doc.ArgVal : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.282","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.283","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.282","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.283","type":"Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"How should this argument be documented in automatically-generated signatures? ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"description","kind":{"const":{"docs":"How should this argument be documented in automatically-generated signatures? ","isDef":true,"name":["Verso","ArgParse","ValDesc","description"],"signature":"ArgParse.SigDoc"}}}}},"projFn":"Verso.ArgParse.ValDesc.description","type":{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Which of the three kinds of values can match this argument? ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"signature","kind":{"const":{"docs":"Which of the three kinds of values can match this argument? ","isDef":true,"name":["Verso","ArgParse","ValDesc","signature"],"signature":"ArgParse.CanMatch"}}}}},"projFn":"Verso.ArgParse.ValDesc.signature","type":{"token":{"tok":{"content":"ArgParse.CanMatch","kind":{"const":{"docs":"Documents which kinds of values a `ValDesc` might match.\n\nThese are typically constructed using `CanMatch.Ident`, `CanMatch.String`, `CanMatch.Num`, and the\n`Union CanMatch` instance.\n","isDef":false,"name":["Verso","ArgParse","CanMatch"],"signature":"Verso.ArgParse.CanMatch : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How to transform the value into the given type. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"get","kind":{"const":{"docs":"How to transform the value into the given type. ","isDef":true,"name":["Verso","ArgParse","ValDesc","get"],"signature":"Doc.ArgVal → m α"}}}}},"projFn":"Verso.ArgParse.ValDesc.get","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Doc.ArgVal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","ArgVal"],"signature":"Verso.Doc.ArgVal : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.277","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.278","type":"Type"}}}}}]}},"visibility":"public"}],"fieldNames":["description","signature","get"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.ValDesc","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.291","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.292","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.ValDesc","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.291","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.292","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":204,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A means of transforming a Verso argument value into a given type."}]},{"other":{"container":{"data":"Constructor","id":205,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.ArgParse.ValDesc.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","ValDesc","mk"],"signature":"Verso.ArgParse.ValDesc.mk {m : Type → Type} {α : Type} (description : ArgParse.SigDoc) (signature : ArgParse.CanMatch)\n (get : Doc.ArgVal → m α) : ArgParse.ValDesc m α"}}}}},null],"id":206,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":207,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"description","kind":{"const":{"docs":"How should this argument be documented in automatically-generated signatures? ","isDef":true,"name":["Verso","ArgParse","ValDesc","description"],"signature":"ArgParse.SigDoc"}}}}},[{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},[null,[]]]]],"id":208,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How should this argument be documented in automatically-generated signatures?"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"signature","kind":{"const":{"docs":"Which of the three kinds of values can match this argument? ","isDef":true,"name":["Verso","ArgParse","ValDesc","signature"],"signature":"ArgParse.CanMatch"}}}}},[{"token":{"tok":{"content":"ArgParse.CanMatch","kind":{"const":{"docs":"Documents which kinds of values a `ValDesc` might match.\n\nThese are typically constructed using `CanMatch.Ident`, `CanMatch.String`, `CanMatch.Num`, and the\n`Union CanMatch` instance.\n","isDef":false,"name":["Verso","ArgParse","CanMatch"],"signature":"Verso.ArgParse.CanMatch : Type"}}}}},[null,[]]]]],"id":209,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Which of the three kinds of values can match this argument?"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"get","kind":{"const":{"docs":"How to transform the value into the given type. ","isDef":true,"name":["Verso","ArgParse","ValDesc","get"],"signature":"Doc.ArgVal → m α"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Doc.ArgVal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Doc","ArgVal"],"signature":"Verso.Doc.ArgVal : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.277","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.278","type":"Type"}}}}}]}},[null,[]]]]],"id":210,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to transform the value into the given type."}]}]}}]}}]}}]},{"para":[{"text":"A canonical value description for a Lean type can be registered via an instance of "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},"id":211,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"FromArgVal"}]}},{"text":":"}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.FromArgVal",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.ArgParse.FromArgVal.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","FromArgVal","mk"],"signature":"Verso.ArgParse.FromArgVal.mk {α : Type} {m : Type → Type} (fromArgVal : ArgParse.ValDesc m α) : ArgParse.FromArgVal α m"}}}}},"name":"Verso.ArgParse.FromArgVal.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgVal.mk","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.329","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.331","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"fromArgVal","kind":{"var":{"name":"_uniq.334","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.331","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.329","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.329","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.331","type":"Type → Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"A canonical way to convert a Verso argument into a given type.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"fromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":true,"name":["Verso","ArgParse","FromArgVal","fromArgVal"],"signature":"ArgParse.ValDesc m α"}}}}},"projFn":"Verso.ArgParse.FromArgVal.fromArgVal","type":{"seq":{"highlights":[{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.325","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.324","type":"Type"}}}}}]}},"visibility":"public"}],"fieldNames":["fromArgVal"],"isClass":true,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgVal","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.337","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.339","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgVal","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.337","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.339","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":212,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A canonical way to convert a Verso argument into a given type."}]},{"other":{"container":{"data":"Instance Constructor","id":213,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.ArgParse.FromArgVal.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","FromArgVal","mk"],"signature":"Verso.ArgParse.FromArgVal.mk {α : Type} {m : Type → Type} (fromArgVal : ArgParse.ValDesc m α) : ArgParse.FromArgVal α m"}}}}},null],"id":214,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Methods","id":215,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"fromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":true,"name":["Verso","ArgParse","FromArgVal","fromArgVal"],"signature":"ArgParse.ValDesc m α"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.325","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.324","type":"Type"}}}}}]}},[null,[]]]]],"id":216,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A canonical way to convert a Verso argument into a given type."}]}]}}]}}]}}]},{"para":[{"text":"In addition to the constructors of "},{"other":{"container":{"data":{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},"id":217,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"ArgParse"}]}},{"text":", the "},{"other":{"container":{"data":{"token":{"tok":{"content":"Applicative","kind":{"const":{"docs":"An [applicative functor](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=monads-and-do) is more powerful than a `Functor`, but\nless powerful than a `Monad`.\n\nApplicative functors capture sequencing of effects with the `<*>` operator, overloaded as `seq`, but\nnot data-dependent effects. The results of earlier computations cannot be used to control later\neffects.\n\nApplicative functors should satisfy four laws. Instances of `Applicative` are not required to prove\nthat they satisfy these laws, which are part of the `LawfulApplicative` class.\n","isDef":false,"name":["Applicative"],"signature":"Applicative.{u, v} (f : Type u → Type v) : Type (max (u + 1) v)"}}}}},"id":218,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Applicative"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Functor","kind":{"const":{"docs":"A functor in the sense used in functional programming, which means a function `f : Type u → Type v`\nhas a way of mapping a function over its contents. This `map` operator is written `<$>`, and\noverloaded via `Functor` instances.\n\nThis `map` function should respect identity and function composition. In other words, for all terms\n`v : f α`, it should be the case that:\n\n * `id <$> v = v`\n\n * For all functions `h : β → γ` and `g : α → β`, `(h ∘ g) <$> v = h <$> g <$> v`\n\nWhile all `Functor` instances should live up to these requirements, they are not required to _prove_\nthat they do. Proofs may be required or provided via the `LawfulFunctor` class.\n\nAssuming that instances are lawful, this definition corresponds to the category-theoretic notion of\n[functor](https://en.wikipedia.org/wiki/Functor) in the special case where the category is the\ncategory of types and functions between them.\n","isDef":false,"name":["Functor"],"signature":"Functor.{u, v} (f : Type u → Type v) : Type (max (u + 1) v)"}}}}},"id":219,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Functor"}]}},{"text":" instances are important, as well as the following helpers:"}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.namedD",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.namedD","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.364","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.365","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.368","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.364","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.369","type":"α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.364","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.namedD","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.364","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.365","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"val","kind":{"var":{"name":"_uniq.368","type":"ArgParse.ValDesc m α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.ValDesc","kind":{"const":{"docs":"A means of transforming a Verso argument value into a given type.\n","isDef":false,"name":["Verso","ArgParse","ValDesc"],"signature":"Verso.ArgParse.ValDesc (m : Type → Type) (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.364","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.369","type":"α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.364","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.362","type":"Type"}}}}}]}}},[null,[]]]]],"id":220,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Matches an argument with the provided name. If the argument is not present, "},{"other":{"container":{"data":{"token":{"tok":{"content":"default","kind":{"const":{"docs":"`default` is a function that produces a \"default\" element of any\n`Inhabited` type. This element does not have any particular specified\nproperties, but it is often an all-zeroes value. ","isDef":false,"name":["Inhabited","default"],"signature":"Inhabited.default.{u} {α : Sort u} [self : Inhabited α] : α"}}}}},"id":221,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"default"}]}},{"text":" is returned."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.positional'",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.positional'","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.387","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.389","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.387","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.389","type":"Type → Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"nameHint","kind":{"var":{"name":"_uniq.393","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.395","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.389","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.387","type":"Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.positional'","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.387","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.389","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.387","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.389","type":"Type → Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"nameHint","kind":{"var":{"name":"_uniq.393","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.395","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.389","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.387","type":"Type"}}}}}]}}},[null,[]]]]],"id":222,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Matches a positional argument using the type's "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgVal","kind":"unknown"}}},"id":223,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"FromArgVal"}]}},{"text":" instance."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.named'",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.named'","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.416","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.416","type":"Type → Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.420","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.421","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.423","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.416","type":"Type → Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"token":{"tok":{"content":"if","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.421","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=","kind":{"const":{"docs":"The equality relation. It has one introduction rule, `Eq.refl`.\nWe use `a = b` as notation for `Eq a b`.\nA fundamental property of equality is that it is an equivalence relation.\n```\nvariable (α : Type) (a b c d : α)\nvariable (hab : a = b) (hcb : c = b) (hcd : c = d)\n\nexample : a = d :=\n Eq.trans (Eq.trans hab (Eq.symm hcb)) hcd\n```\nEquality is much more than an equivalence relation, however. It has the important property that every assertion\nrespects the equivalence, in the sense that we can substitute equal expressions without changing the truth value.\nThat is, given `h1 : a = b` and `h2 : p a`, we can construct a proof for `p b` using substitution: `Eq.subst h1 h2`.\nExample:\n```\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n Eq.subst h1 h2\n\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n h1 ▸ h2\n```\nThe triangle in the second presentation is a macro built on top of `Eq.subst` and `Eq.symm`, and you can enter it by typing `\\t`.\nFor more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `=` in identifiers is `eq`.","isDef":false,"name":["Eq"],"signature":"Eq.{u_1} {α : Sort u_1} : α → α → Prop"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"then","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"else","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.named'","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.416","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.416","type":"Type → Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.420","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.421","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc?","kind":{"var":{"name":"_uniq.423","type":"optParam (Option ArgParse.SigDoc) none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ArgParse.SigDoc","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","ArgParse","SigDoc"],"signature":"Verso.ArgParse.SigDoc : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.416","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"token":{"tok":{"content":"if","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"optional","kind":{"var":{"name":"_uniq.421","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=","kind":{"const":{"docs":"The equality relation. It has one introduction rule, `Eq.refl`.\nWe use `a = b` as notation for `Eq a b`.\nA fundamental property of equality is that it is an equivalence relation.\n```\nvariable (α : Type) (a b c d : α)\nvariable (hab : a = b) (hcb : c = b) (hcd : c = d)\n\nexample : a = d :=\n Eq.trans (Eq.trans hab (Eq.symm hcb)) hcd\n```\nEquality is much more than an equivalence relation, however. It has the important property that every assertion\nrespects the equivalence, in the sense that we can substitute equal expressions without changing the truth value.\nThat is, given `h1 : a = b` and `h2 : p a`, we can construct a proof for `p b` using substitution: `Eq.subst h1 h2`.\nExample:\n```\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n Eq.subst h1 h2\n\nexample (α : Type) (a b : α) (p : α → Prop)\n (h1 : a = b) (h2 : p a) : p b :=\n h1 ▸ h2\n```\nThe triangle in the second presentation is a macro built on top of `Eq.subst` and `Eq.symm`, and you can enter it by typing `\\t`.\nFor more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `=` in identifiers is `eq`.","isDef":false,"name":["Eq"],"signature":"Eq.{u_1} {α : Sort u_1} : α → α → Prop"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"then","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"else","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.414","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"`if c then t else e` is notation for `ite c t e`, \"if-then-else\", which decides to\nreturn `t` or `e` depending on whether `c` is true or false. The explicit argument\n`c : Prop` does not have any actual computational content, but there is an additional\n`[Decidable c]` argument synthesized by typeclass inference which actually\ndetermines how to evaluate `c` to true or false. Write `if h : c then t else e`\ninstead for a \"dependent if-then-else\" `dite`, which allows `t`/`e` to use the fact\nthat `c` is true/false.\n","isDef":false,"name":["ite"],"signature":"ite.{u} {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α"}}}}}]}}},[null,[]]]]],"id":224,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Matches a named argument using the type's "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgVal","kind":"unknown"}}},"id":225,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"FromArgVal"}]}},{"text":" instance."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.ArgParse.namedD'",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.namedD'","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.445","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.445","type":"Type → Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.449","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.450","type":"α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.445","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.ArgParse.namedD'","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.445","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"ArgParse.FromArgVal","kind":{"const":{"docs":"A canonical way to convert a Verso argument into a given type.\n","isDef":false,"name":["Verso","ArgParse","FromArgVal"],"signature":"Verso.ArgParse.FromArgVal (α : Type) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.445","type":"Type → Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.449","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"default","kind":{"var":{"name":"_uniq.450","type":"α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"ArgParse","kind":{"const":{"docs":"A parser for arguments in some underlying monad.\n","isDef":false,"name":["Verso","ArgParse"],"signature":"Verso.ArgParse (m : Type → Type) : Type → Type 1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.445","type":"Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.443","type":"Type"}}}}}]}}},[null,[]]]]],"id":226,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Matches an argument with the provided name using the type's "},{"other":{"container":{"data":{"token":{"tok":{"content":"FromArgVal","kind":"unknown"}}},"id":227,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"FromArgVal"}]}},{"text":" instance. If the argument"},{"text":"\n"},{"text":"is not present, "},{"other":{"container":{"data":{"token":{"tok":{"content":"default","kind":{"const":{"docs":"`default` is a function that produces a \"default\" element of any\n`Inhabited` type. This element does not have any particular specified\nproperties, but it is often an all-zeroes value. ","isDef":false,"name":["Inhabited","default"],"signature":"Inhabited.default.{u} {α : Sort u} [self : Inhabited α] : α"}}}}},"id":228,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"default"}]}},{"text":" is returned."}]}]}}]}],"metadata":{"assignedNumber":1,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":179,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"ArgParse"}}},"subParts":[],"title":[{"text":"Parsing Arguments"}],"titleString":"Parsing Arguments"}],"title":[{"text":"Elaborating Extensions"}],"titleString":"Elaborating Extensions"}],"title":[{"text":"Extensions"}],"titleString":"Extensions"},{"content":[{"para":[{"text":"Verso provides genre authors with tools for generating HTML and TeX code via embedded languages that reduce the syntactic overhead of constructing ASTs."},{"linebreak":"\n"},{"text":"These libraries may also be used by authors of extensions to the "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},"id":230,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual"}]}},{"text":" genre, who need to define how each new element should be rendered to each supported backend."}]}],"metadata":{"assignedNumber":5,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"never","htmlToc":true,"id":229,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"outputs"}}},"subParts":[{"content":[{"para":[{"text":"Verso's "},{"other":{"container":{"data":{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},"id":232,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Html"}]}},{"text":" type represents HTML documents."},{"linebreak":"\n"},{"text":"They are typically produced using an embedded DSL that is available when the namespace "},{"code":"Verso.Output.Html"},{"text":" is opened."}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html",[{"inductive":{"constructors":[{"docstring":"Textual content. If `escape` is `true`, then characters such as `'&'` are escaped to entities such\nas `\"&\"` during rendering.\n","hlName":{"token":{"tok":{"content":"text","kind":{"const":{"docs":"Textual content. If `escape` is `true`, then characters such as `'&'` are escaped to entities such\nas `\"&\"` during rendering.\n","isDef":false,"name":["Verso","Output","Html","text"],"signature":"Verso.Output.Html.text (escape : Bool) (string : String) : Html"}}}}},"name":"Verso.Output.Html.text","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"text","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"escape","kind":{"var":{"name":"_uniq.12","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"string","kind":{"var":{"name":"_uniq.13","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},{"docstring":"A tag with the given name and attributes.\n","hlName":{"token":{"tok":{"content":"tag","kind":{"const":{"docs":"A tag with the given name and attributes.\n","isDef":false,"name":["Verso","Output","Html","tag"],"signature":"Verso.Output.Html.tag (name : String) (attrs : Array (String × String)) (contents : Html) : Html"}}}}},"name":"Verso.Output.Html.tag","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"tag","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.14","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"attrs","kind":{"var":{"name":"_uniq.15","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.16","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},{"docstring":"A sequence of HTML values.\n","hlName":{"token":{"tok":{"content":"seq","kind":{"const":{"docs":"A sequence of HTML values.\n","isDef":false,"name":["Verso","Output","Html","seq"],"signature":"Verso.Output.Html.seq (contents : Array Html) : Html"}}}}},"name":"Verso.Output.Html.seq","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"seq","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.17","type":"Array Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":233,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A representation of HTML, used to render Verso to the web."}]},{"other":{"container":{"data":"Constructors","id":234,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"text","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"escape","kind":{"var":{"name":"_uniq.12","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"string","kind":{"var":{"name":"_uniq.13","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"id":235,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Textual content. If "},{"other":{"container":{"data":{"token":{"tok":{"content":"escape","kind":{"var":{"name":"_uniq.18","type":"Bool"}}}}},"id":236,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"escape"}]}},{"text":" is "},{"other":{"container":{"data":{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},"id":237,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"true"}]}},{"text":", then characters such as "},{"other":{"container":{"data":{"token":{"tok":{"content":"'&'","kind":"unknown"}}},"id":238,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"'&'"}]}},{"text":" are escaped to entities such"},{"text":"\n"},{"text":"as "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"&\"","kind":{"str":{"string":"&"}}}}},"id":239,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"&\""}]}},{"text":" during rendering."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"tag","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.14","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"attrs","kind":{"var":{"name":"_uniq.15","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.16","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"id":240,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A tag with the given name and attributes."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"seq","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.17","type":"Array Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"id":241,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A sequence of HTML values."}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.empty",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.empty","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.empty","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},[null,["Verso.Output.Html.nil","Verso.Output.Html.none"]]]]],"id":242,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"The empty HTML document."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.fromArray",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.fromArray","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmls","kind":{"var":{"name":"_uniq.29","type":"Array Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.fromArray","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmls","kind":{"var":{"name":"_uniq.29","type":"Array Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},[null,[]]]]],"id":243,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Converts an array of HTML elements into a single element by appending them."}]},{"para":[{"text":"This is equivalent to using "},{"other":{"container":{"data":{"token":{"tok":{"content":"Html.seq","kind":{"const":{"docs":"A sequence of HTML values.\n","isDef":false,"name":["Verso","Output","Html","seq"],"signature":"Verso.Output.Html.seq (contents : Array Html) : Html"}}}}},"id":244,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Html.seq"}]}},{"text":", but may result a more compact representation."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.fromList",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.fromList","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmls","kind":{"var":{"name":"_uniq.34","type":"List Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.fromList","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmls","kind":{"var":{"name":"_uniq.34","type":"List Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},[null,[]]]]],"id":245,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Converts a list of HTML elements into a single element by appending them."}]},{"para":[{"text":"This is equivalent to using "},{"other":{"container":{"data":{"token":{"tok":{"content":"Html.seq","kind":{"const":{"docs":"A sequence of HTML values.\n","isDef":false,"name":["Verso","Output","Html","seq"],"signature":"Verso.Output.Html.seq (contents : Array Html) : Html"}}}}},"id":246,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Html.seq"}]}},{"text":" on the corresponding array, but may result in a more compact representation."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.append",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.append","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.append","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},[null,[]]]]],"id":247,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Appends two HTML documents."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.visitM",[{"opaque":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.visitM.{u_1}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type u_1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"Monad","kind":{"const":{"docs":"[Monads](https://en.wikipedia.org/wiki/Monad_(functional_programming)) are an abstraction of\nsequential control flow and side effects used in functional programming. Monads allow both\nsequencing of effects and data-dependent effects: the values that result from an early step may\ninfluence the effects carried out in a later step.\n\nThe `Monad` API may be used directly. However, it is most commonly accessed through\n[`do`-notation](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation).\n\nMost `Monad` instances provide implementations of `pure` and `bind`, and use default implementations\nfor the other methods inherited from `Applicative`. Monads should satisfy certain laws, but\ninstances are not required to prove this. An instance of `LawfulMonad` expresses that a given\nmonad's operations are lawful.\n","isDef":false,"name":["Monad"],"signature":"Monad.{u, v} (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.69","type":"optParam (Bool → String → m (Option Html)) fun x x_1 => pure none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"fun","kind":{"keyword":{"docs":null,"name":null,"occurrence":null}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x","kind":{"var":{"name":"_uniq.66","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x_1","kind":{"var":{"name":"_uniq.67","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Given `a : α`, then `pure a : f α` represents an action that does nothing and returns `a`.\n\nExamples:\n* `(pure \"hello\" : Option String) = some \"hello\"`\n* `(pure \"hello\" : Except (Array String) String) = Except.ok \"hello\"`\n* `(pure \"hello\" : StateM Nat String).run 105 = (\"hello\", 105)`\n","isDef":false,"name":["Pure","pure"],"signature":"Pure.pure.{u, v} {f : Type u → Type v} [self : Pure f] {α : Type u} : α → f α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"tag","kind":{"var":{"name":"_uniq.86","type":"optParam (String → Array (String × String) → Html → m (Option Html)) fun x x_1 x_2 => pure none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"fun","kind":{"keyword":{"docs":null,"name":null,"occurrence":null}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x","kind":{"var":{"name":"_uniq.81","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x_1","kind":{"var":{"name":"_uniq.83","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x_2","kind":{"var":{"name":"_uniq.84","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Given `a : α`, then `pure a : f α` represents an action that does nothing and returns `a`.\n\nExamples:\n* `(pure \"hello\" : Option String) = some \"hello\"`\n* `(pure \"hello\" : Except (Array String) String) = Except.ok \"hello\"`\n* `(pure \"hello\" : StateM Nat String).run 105 = (\"hello\", 105)`\n","isDef":false,"name":["Pure","pure"],"signature":"Pure.pure.{u, v} {f : Type u → Type v} [self : Pure f] {α : Type u} : α → f α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"seq","kind":{"var":{"name":"_uniq.94","type":"optParam (Array Html → m (Option Html)) fun x => pure none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"fun","kind":{"keyword":{"docs":null,"name":null,"occurrence":null}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x","kind":{"var":{"name":"_uniq.92","type":"Array Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Given `a : α`, then `pure a : f α` represents an action that does nothing and returns `a`.\n\nExamples:\n* `(pure \"hello\" : Option String) = some \"hello\"`\n* `(pure \"hello\" : Except (Array String) String) = Except.ok \"hello\"`\n* `(pure \"hello\" : StateM Nat String).run 105 = (\"hello\", 105)`\n","isDef":false,"name":["Pure","pure"],"signature":"Pure.pure.{u, v} {f : Type u → Type v} [self : Pure f] {α : Type u} : α → f α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.96","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.visitM.{u_1}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type u_1","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"Monad","kind":{"const":{"docs":"[Monads](https://en.wikipedia.org/wiki/Monad_(functional_programming)) are an abstraction of\nsequential control flow and side effects used in functional programming. Monads allow both\nsequencing of effects and data-dependent effects: the values that result from an early step may\ninfluence the effects carried out in a later step.\n\nThe `Monad` API may be used directly. However, it is most commonly accessed through\n[`do`-notation](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=do-notation).\n\nMost `Monad` instances provide implementations of `pure` and `bind`, and use default implementations\nfor the other methods inherited from `Applicative`. Monads should satisfy certain laws, but\ninstances are not required to prove this. An instance of `LawfulMonad` expresses that a given\nmonad's operations are lawful.\n","isDef":false,"name":["Monad"],"signature":"Monad.{u, v} (m : Type u → Type v) : Type (max (u + 1) v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.69","type":"optParam (Bool → String → m (Option Html)) fun x x_1 => pure none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"fun","kind":{"keyword":{"docs":null,"name":null,"occurrence":null}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x","kind":{"var":{"name":"_uniq.66","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x_1","kind":{"var":{"name":"_uniq.67","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Given `a : α`, then `pure a : f α` represents an action that does nothing and returns `a`.\n\nExamples:\n* `(pure \"hello\" : Option String) = some \"hello\"`\n* `(pure \"hello\" : Except (Array String) String) = Except.ok \"hello\"`\n* `(pure \"hello\" : StateM Nat String).run 105 = (\"hello\", 105)`\n","isDef":false,"name":["Pure","pure"],"signature":"Pure.pure.{u, v} {f : Type u → Type v} [self : Pure f] {α : Type u} : α → f α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"tag","kind":{"var":{"name":"_uniq.86","type":"optParam (String → Array (String × String) → Html → m (Option Html)) fun x x_1 x_2 => pure none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"fun","kind":{"keyword":{"docs":null,"name":null,"occurrence":null}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x","kind":{"var":{"name":"_uniq.81","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x_1","kind":{"var":{"name":"_uniq.83","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x_2","kind":{"var":{"name":"_uniq.84","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Given `a : α`, then `pure a : f α` represents an action that does nothing and returns `a`.\n\nExamples:\n* `(pure \"hello\" : Option String) = some \"hello\"`\n* `(pure \"hello\" : Except (Array String) String) = Except.ok \"hello\"`\n* `(pure \"hello\" : StateM Nat String).run 105 = (\"hello\", 105)`\n","isDef":false,"name":["Pure","pure"],"signature":"Pure.pure.{u, v} {f : Type u → Type v} [self : Pure f] {α : Type u} : α → f α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"seq","kind":{"var":{"name":"_uniq.94","type":"optParam (Array Html → m (Option Html)) fun x => pure none"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"fun","kind":{"keyword":{"docs":null,"name":null,"occurrence":null}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"x","kind":{"var":{"name":"_uniq.92","type":"Array Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"=>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pure","kind":{"const":{"docs":"Given `a : α`, then `pure a : f α` represents an action that does nothing and returns `a`.\n\nExamples:\n* `(pure \"hello\" : Option String) = some \"hello\"`\n* `(pure \"hello\" : Except (Array String) String) = Except.ok \"hello\"`\n* `(pure \"hello\" : StateM Nat String).run 105 = (\"hello\", 105)`\n","isDef":false,"name":["Pure","pure"],"signature":"Pure.pure.{u, v} {f : Type u → Type v} [self : Pure f] {α : Type u} : α → f α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.96","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"m","kind":{"var":{"name":"_uniq.58","type":"Type → Type u_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},[null,[]]]]],"id":248,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Visit the entire tree, applying rewrites in some monad. Return "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":249,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":" to signal that no rewrites are"},{"text":"\n"},{"text":"to be performed."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.format",[{"opaque":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.format","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Std.Format","kind":{"const":{"docs":"A representation of a set of strings, in which the placement of newlines and indentation differ.\n\nGiven a specific line width, specified in columns, the string that uses the fewest lines can be\nselected.\n\nThe pretty-printing algorithm is based on Wadler's paper\n[_A Prettier Printer_](https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf).\n","isDef":false,"name":["Std","Format"],"signature":"Std.Format : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.format","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Std.Format","kind":{"const":{"docs":"A representation of a set of strings, in which the placement of newlines and indentation differ.\n\nGiven a specific line width, specified in columns, the string that uses the fewest lines can be\nselected.\n\nThe pretty-printing algorithm is based on Wadler's paper\n[_A Prettier Printer_](https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf).\n","isDef":false,"name":["Std","Format"],"signature":"Std.Format : Type"}}}}}]}}},[null,[]]]]],"id":250,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Converts HTML into a pretty-printer document. This is useful for debugging, but it does not preserve"},{"text":"\n"},{"text":"whitespace around preformatted content and scripts."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.Html.asString",[{"opaque":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.asString","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.105","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"indent","kind":{"var":{"name":"_uniq.106","type":"optParam Nat 0"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Nat","kind":{"const":{"docs":"The natural numbers, starting at zero.\n\nThis type is special-cased by both the kernel and the compiler, and overridden with an efficient\nimplementation. Both use a fast arbitrary-precision arithmetic library (usually\n[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.\n","isDef":false,"name":["Nat"],"signature":"Nat : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"0","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"breakLines","kind":{"var":{"name":"_uniq.107","type":"optParam Bool true"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.Html.asString","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.105","type":"Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"indent","kind":{"var":{"name":"_uniq.106","type":"optParam Nat 0"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Nat","kind":{"const":{"docs":"The natural numbers, starting at zero.\n\nThis type is special-cased by both the kernel and the compiler, and overridden with an efficient\nimplementation. Both use a fast arbitrary-precision arithmetic library (usually\n[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.\n","isDef":false,"name":["Nat"],"signature":"Nat : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"0","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"breakLines","kind":{"var":{"name":"_uniq.107","type":"optParam Bool true"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}}},[null,[]]]]],"id":251,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Converts HTML into a string that's suitable for sending to browsers, but is also readable."}]}]}}]},{"para":[{"text":"HTML documents are written in double curly braces, in a syntax very much like HTML itself."},{"linebreak":"\n"},{"text":"The differences are:"}]},{"ul":[{"contents":[{"para":[{"text":"Double curly braces escape back to Lean. This can be done for HTML elements, attribute values, or whole sets of attributes."}]}]},{"contents":[{"para":[{"text":"Text content is written as Lean string literals to facilitate precise control over whitespace."}]}]},{"contents":[{"para":[{"text":"Interpolated Lean strings (with "},{"code":"s!"},{"text":") may be used in any context that expects a string."}]}]}]},{"para":[{"text":"For example, this definition creates a "},{"code":"
"},{"text":" list:"}]},{"concat":[{"other":{"container":{"data":[{"seq":{"highlights":[{"token":{"tok":{"content":"open","kind":{"keyword":{"docs":"Makes names from other namespaces visible without writing the namespace prefix.\n\nNames that are made available with `open` are visible within the current `section` or `namespace`\nblock. This makes referring to (type) definitions and theorems easier, but note that it can also\nmake [scoped instances], notations, and attributes from a different namespace available.\n\nThe `open` command can be used in a few different ways:\n\n* `open Some.Namespace.Path1 Some.Namespace.Path2` makes all non-protected names in\n `Some.Namespace.Path1` and `Some.Namespace.Path2` available without the prefix, so that\n `Some.Namespace.Path1.x` and `Some.Namespace.Path2.y` can be referred to by writing only `x` and\n `y`.\n\n* `open Some.Namespace.Path hiding def1 def2` opens all non-protected names in `Some.Namespace.Path`\n except `def1` and `def2`.\n\n* `open Some.Namespace.Path (def1 def2)` only makes `Some.Namespace.Path.def1` and\n `Some.Namespace.Path.def2` available without the full prefix, so `Some.Namespace.Path.def3` would\n be unaffected.\n\n This works even if `def1` and `def2` are `protected`.\n\n* `open Some.Namespace.Path renaming def1 → def1', def2 → def2'` same as `open Some.Namespace.Path\n (def1 def2)` but `def1`/`def2`'s names are changed to `def1'`/`def2'`.\n\n This works even if `def1` and `def2` are `protected`.\n\n* `open scoped Some.Namespace.Path1 Some.Namespace.Path2` **only** opens [scoped instances],\n notations, and attributes from `Namespace1` and `Namespace2`; it does **not** make any other name\n available.\n\n* `open in` makes the names `open`-ed visible only in the next\n command or expression.\n\n[scoped instance]: https://lean-lang.org/theorem_proving_in_lean4/type_classes.html#scoped-instances\n(Scoped instances in Theorem Proving in Lean)\n\n\n## Examples\n\n```lean\n/-- SKI combinators https://en.wikipedia.org/wiki/SKI_combinator_calculus -/\nnamespace Combinator.Calculus\n def I (a : α) : α := a\n def K (a : α) : β → α := fun _ => a\n def S (x : α → β → γ) (y : α → β) (z : α) : γ := x z (y z)\nend Combinator.Calculus\n\nsection\n -- open everything under `Combinator.Calculus`, *i.e.* `I`, `K` and `S`,\n -- until the section ends\n open Combinator.Calculus\n\n theorem SKx_eq_K : S K x = I := rfl\nend\n\n-- open everything under `Combinator.Calculus` only for the next command (the next `theorem`, here)\nopen Combinator.Calculus in\ntheorem SKx_eq_K' : S K x = I := rfl\n\nsection\n -- open only `S` and `K` under `Combinator.Calculus`\n open Combinator.Calculus (S K)\n\n theorem SKxy_eq_y : S K x y = y := rfl\n\n -- `I` is not in scope, we have to use its full path\n theorem SKxy_eq_Iy : S K x y = Combinator.Calculus.I y := rfl\nend\n\nsection\n open Combinator.Calculus\n renaming\n I → identity,\n K → konstant\n\n #check identity\n #check konstant\nend\n\nsection\n open Combinator.Calculus\n hiding S\n\n #check I\n #check K\nend\n\nsection\n namespace Demo\n inductive MyType\n | val\n\n namespace N1\n scoped infix:68 \" ≋ \" => BEq.beq\n\n scoped instance : BEq MyType where\n beq _ _ := true\n\n def Alias := MyType\n end N1\n end Demo\n\n -- bring `≋` and the instance in scope, but not `Alias`\n open scoped Demo.N1\n\n #check Demo.MyType.val == Demo.MyType.val\n #check Demo.MyType.val ≋ Demo.MyType.val\n -- #check Alias -- unknown identifier 'Alias'\nend\n```\n","name":["Lean","Parser","Command","open"],"occurrence":"Lean.Parser.Command.open-1673"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Verso.Output.Html","kind":"unknown"}}},{"text":{"str":"\n\n"}},{"token":{"tok":{"content":"def","kind":{"keyword":{"docs":null,"name":["Lean","Parser","Command","definition"],"occurrence":"Lean.Parser.Command.definition-1697"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"mkList","kind":{"const":{"docs":null,"isDef":true,"name":["mkList"],"signature":"mkList (xs : List Html) : Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"xs","kind":{"var":{"name":"_uniq.3","type":"List Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{{","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"ul","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{{","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"xs","kind":{"var":{"name":"_uniq.3","type":"List Html"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"map","kind":{"const":{"docs":"Applies a function to each element of the list, returning the resulting list of values.\n\n`O(|l|)`.\n\nExamples:\n* `[a, b, c].map f = [f a, f b, f c]`\n* `[].map Nat.succ = []`\n* `[\"one\", \"two\", \"three\"].map (·.length) = [3, 3, 5]`\n* `[\"one\", \"two\", \"three\"].map (·.reverse) = [\"eno\", \"owt\", \"eerht\"]`\n","isDef":false,"name":["List","map"],"signature":"List.map.{u_1, u_2} {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) : List β"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"{{","kind":"unknown"}}},{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"li","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}},{"token":{"tok":{"content":"{{","kind":"unknown"}}},{"token":{"tok":{"content":"·","kind":"unknown"}}},{"token":{"tok":{"content":"}}","kind":"unknown"}}},{"token":{"tok":{"content":"","kind":"unknown"}}},{"token":{"tok":{"content":"}}","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"}}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"","kind":"unknown"}}},{"token":{"tok":{"content":"}}","kind":"unknown"}}},{"text":{"str":"\n\n"}},{"span":{"content":{"token":{"tok":{"content":"#eval","kind":{"keyword":{"docs":"`#eval e` evaluates the expression `e` by compiling and evaluating it.\n\n* The command attempts to use `ToExpr`, `Repr`, or `ToString` instances to print the result.\n* If `e` is a monadic value of type `m ty`, then the command tries to adapt the monad `m`\n to one of the monads that `#eval` supports, which include `IO`, `CoreM`, `MetaM`, `TermElabM`, and `CommandElabM`.\n Users can define `MonadEval` instances to extend the list of supported monads.\n\nThe `#eval` command gracefully degrades in capability depending on what is imported.\nImporting the `Lean.Elab.Command` module provides full capabilities.\n\nDue to unsoundness, `#eval` refuses to evaluate expressions that depend on `sorry`, even indirectly,\nsince the presence of `sorry` can lead to runtime instability and crashes.\nThis check can be overridden with the `#eval! e` command.\n\nOptions:\n* If `eval.pp` is true (default: true) then tries to use `ToExpr` instances to make use of the\n usual pretty printer. Otherwise, only tries using `Repr` and `ToString` instances.\n* If `eval.type` is true (default: false) then pretty prints the type of the evaluated value.\n* If `eval.derive.repr` is true (default: true) then attempts to auto-derive a `Repr` instance\n when there is no other way to print the result.\n\nSee also: `#reduce e` for evaluation by term reduction.\n","name":["Lean","Parser","Command","eval"],"occurrence":"Lean.Parser.Command.eval-1789"}}}}},"info":[["info",{"append":[{"text":""},{"text":"\n\n"}]}]]}},{"text":{"str":" "}},{"token":{"tok":{"content":"mkList","kind":{"const":{"docs":null,"isDef":false,"name":["mkList"],"signature":"mkList (xs : List Html) : Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"\"A\"","kind":{"str":{"string":"A"}}}}},{"token":{"tok":{"content":",","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{{","kind":"unknown"}}},{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"emph","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}},{"token":{"tok":{"content":"\"B\"","kind":{"str":{"string":"B"}}}}},{"token":{"tok":{"content":"","kind":"unknown"}}},{"token":{"tok":{"content":"}}","kind":"unknown"}}},{"token":{"tok":{"content":",","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"\"C\"","kind":{"str":{"string":"C"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"|>.","kind":"unknown"}}},{"token":{"tok":{"content":"asString","kind":{"const":{"docs":"Converts HTML into a string that's suitable for sending to browsers, but is also readable.\n","isDef":false,"name":["Verso","Output","Html","asString"],"signature":"Verso.Output.Html.asString (html : Html) (indent : Nat := 0) (breakLines : Bool := true) : String"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"|>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO.println","kind":{"const":{"docs":"Converts `s` to a string using its `ToString α` instance, and prints it with a trailing newline to\nthe current standard output (as determined by `IO.getStdout`).\n","isDef":false,"name":["IO","println"],"signature":"IO.println.{u_1} {α : Type u_1} [ToString α] (s : α) : IO Unit"}}}}},{"text":{"str":"\n"}},{"token":{"tok":{"content":"","kind":"unknown"}}}]}},[["mkList","mkList"]],"/home/runner/work/verso/verso/doc/UsersGuide/Output.lean",{"end":{"character":0,"line":67},"start":{"character":0,"line":59}}],"id":252,"name":"Verso.Genre.Manual.InlineLean.Block.lean","properties":{}},"content":[{"code":"open Verso.Output.Html\n\ndef mkList (xs : List Html) : Html :=\n {{ }}\n\n#eval mkList [\"A\", {{\"B\"}}, \"C\"]\n |>.asString\n |> IO.println\n"}]}}]},{"concat":[{"other":{"container":{"data":[{"contents":{"append":[{"text":""},{"append":[{"text":""},{"text":"\n\n"}]}]},"severity":"info"},[false,[]]],"id":254,"name":"Verso.Genre.Manual.InlineLean.Block.leanOutput","properties":{}},"content":[{"code":"\n"}]}}]}],"metadata":{"assignedNumber":1,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":231,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"output-html"}}},"subParts":[],"title":[{"text":"HTML"}],"titleString":"HTML"},{"content":[{"para":[{"text":"Verso's "},{"other":{"container":{"data":{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},"id":256,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"TeX"}]}},{"text":" type represents LaTeX documents."},{"linebreak":"\n"},{"text":"They are typically produced using an embedded DSL that is available when the namespace "},{"code":"Verso.Output.TeX"},{"text":" is opened."}]},{"concat":[{"other":{"container":{"data":["Verso.Output.TeX",[{"inductive":{"constructors":[{"docstring":"Text to be shown in the document, escaped as needed. ","hlName":{"token":{"tok":{"content":"text","kind":{"const":{"docs":"Text to be shown in the document, escaped as needed. ","isDef":false,"name":["Verso","Output","TeX","text"],"signature":"Verso.Output.TeX.text (string : String) : TeX"}}}}},"name":"Verso.Output.TeX.text","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"text","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"string","kind":{"var":{"name":"_uniq.117","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}},{"docstring":"Raw TeX code to be included without escaping. ","hlName":{"token":{"tok":{"content":"raw","kind":{"const":{"docs":"Raw TeX code to be included without escaping. ","isDef":false,"name":["Verso","Output","TeX","raw"],"signature":"Verso.Output.TeX.raw (string : String) : TeX"}}}}},"name":"Verso.Output.TeX.raw","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"raw","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"string","kind":{"var":{"name":"_uniq.118","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}},{"docstring":"A LaTeX command, with the provided optional and mandatory arguments (in square and curly brackets, respectively) ","hlName":{"token":{"tok":{"content":"command","kind":{"const":{"docs":"A LaTeX command, with the provided optional and mandatory arguments (in square and curly brackets, respectively) ","isDef":false,"name":["Verso","Output","TeX","command"],"signature":"Verso.Output.TeX.command (name : String) (optArgs args : Array TeX) : TeX"}}}}},"name":"Verso.Output.TeX.command","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"command","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.119","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optArgs","kind":{"var":{"name":"_uniq.120","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"args","kind":{"var":{"name":"_uniq.121","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}},{"docstring":"A LaTeX environment, with the provided optional and mandatory arguments (in square and curly brackets, respectively) ","hlName":{"token":{"tok":{"content":"environment","kind":{"const":{"docs":"A LaTeX environment, with the provided optional and mandatory arguments (in square and curly brackets, respectively) ","isDef":false,"name":["Verso","Output","TeX","environment"],"signature":"Verso.Output.TeX.environment (name : String) (optArgs args content : Array TeX) : TeX"}}}}},"name":"Verso.Output.TeX.environment","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"environment","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.122","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optArgs","kind":{"var":{"name":"_uniq.123","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"args","kind":{"var":{"name":"_uniq.124","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"content","kind":{"var":{"name":"_uniq.125","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}},{"docstring":"A paragraph break, rendered to TeX as a blank line ","hlName":{"token":{"tok":{"content":"paragraphBreak","kind":{"const":{"docs":"A paragraph break, rendered to TeX as a blank line ","isDef":false,"name":["Verso","Output","TeX","paragraphBreak"],"signature":"Verso.Output.TeX.paragraphBreak : TeX"}}}}},"name":"Verso.Output.TeX.paragraphBreak","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"paragraphBreak","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}},{"docstring":"Concatenation of TeX ","hlName":{"token":{"tok":{"content":"seq","kind":{"const":{"docs":"Concatenation of TeX ","isDef":false,"name":["Verso","Output","TeX","seq"],"signature":"Verso.Output.TeX.seq (contents : Array TeX) : TeX"}}}}},"name":"Verso.Output.TeX.seq","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"seq","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.126","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.TeX","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.TeX","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":257,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"TeX output"}]},{"other":{"container":{"data":"Constructors","id":258,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"text","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"string","kind":{"var":{"name":"_uniq.117","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"id":259,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Text to be shown in the document, escaped as needed."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"raw","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"string","kind":{"var":{"name":"_uniq.118","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"id":260,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Raw TeX code to be included without escaping."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"command","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.119","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optArgs","kind":{"var":{"name":"_uniq.120","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"args","kind":{"var":{"name":"_uniq.121","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"id":261,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A LaTeX command, with the provided optional and mandatory arguments (in square and curly brackets, respectively)"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"environment","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.122","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"optArgs","kind":{"var":{"name":"_uniq.123","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"args","kind":{"var":{"name":"_uniq.124","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"content","kind":{"var":{"name":"_uniq.125","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"id":262,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A LaTeX environment, with the provided optional and mandatory arguments (in square and curly brackets, respectively)"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"paragraphBreak","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"id":263,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A paragraph break, rendered to TeX as a blank line"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"seq","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.126","type":"Array TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"id":264,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Concatenation of TeX"}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.TeX.empty",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.TeX.empty","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.TeX.empty","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}}]}}},[null,[]]]]],"id":265,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"The empty TeX document"}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Output.TeX.asString",[{"opaque":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.TeX.asString","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc","kind":{"var":{"name":"_uniq.140","type":"TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Output.TeX.asString","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"doc","kind":{"var":{"name":"_uniq.140","type":"TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}}},[null,[]]]]],"id":266,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Converts a TeX document to a string to be processed by LaTeX"}]}]}}]},{"para":[{"text":"TeX documents are written in "},{"code":"\\TeX{...}"},{"text":", in a syntax very much like LaTeX itself."},{"linebreak":"\n"},{"text":"The differences are:"}]},{"ul":[{"contents":[{"para":[{"code":"\\Lean{...}"},{"text":" escapes back to Lean, expecting a value of type "},{"other":{"container":{"data":{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},"id":267,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"TeX"}]}},{"text":"."}]}]},{"contents":[{"para":[{"text":"Text content is written as Lean string literals to facilitate precise control over whitespace."}]}]},{"contents":[{"para":[{"text":"Interpolated Lean strings (with "},{"code":"s!"},{"text":") may be used in any context that expects a string."}]}]}]},{"para":[{"text":"For example, this definition creates a bulleted list list:"}]},{"concat":[{"other":{"container":{"data":[{"seq":{"highlights":[{"token":{"tok":{"content":"open","kind":{"keyword":{"docs":"Makes names from other namespaces visible without writing the namespace prefix.\n\nNames that are made available with `open` are visible within the current `section` or `namespace`\nblock. This makes referring to (type) definitions and theorems easier, but note that it can also\nmake [scoped instances], notations, and attributes from a different namespace available.\n\nThe `open` command can be used in a few different ways:\n\n* `open Some.Namespace.Path1 Some.Namespace.Path2` makes all non-protected names in\n `Some.Namespace.Path1` and `Some.Namespace.Path2` available without the prefix, so that\n `Some.Namespace.Path1.x` and `Some.Namespace.Path2.y` can be referred to by writing only `x` and\n `y`.\n\n* `open Some.Namespace.Path hiding def1 def2` opens all non-protected names in `Some.Namespace.Path`\n except `def1` and `def2`.\n\n* `open Some.Namespace.Path (def1 def2)` only makes `Some.Namespace.Path.def1` and\n `Some.Namespace.Path.def2` available without the full prefix, so `Some.Namespace.Path.def3` would\n be unaffected.\n\n This works even if `def1` and `def2` are `protected`.\n\n* `open Some.Namespace.Path renaming def1 → def1', def2 → def2'` same as `open Some.Namespace.Path\n (def1 def2)` but `def1`/`def2`'s names are changed to `def1'`/`def2'`.\n\n This works even if `def1` and `def2` are `protected`.\n\n* `open scoped Some.Namespace.Path1 Some.Namespace.Path2` **only** opens [scoped instances],\n notations, and attributes from `Namespace1` and `Namespace2`; it does **not** make any other name\n available.\n\n* `open in` makes the names `open`-ed visible only in the next\n command or expression.\n\n[scoped instance]: https://lean-lang.org/theorem_proving_in_lean4/type_classes.html#scoped-instances\n(Scoped instances in Theorem Proving in Lean)\n\n\n## Examples\n\n```lean\n/-- SKI combinators https://en.wikipedia.org/wiki/SKI_combinator_calculus -/\nnamespace Combinator.Calculus\n def I (a : α) : α := a\n def K (a : α) : β → α := fun _ => a\n def S (x : α → β → γ) (y : α → β) (z : α) : γ := x z (y z)\nend Combinator.Calculus\n\nsection\n -- open everything under `Combinator.Calculus`, *i.e.* `I`, `K` and `S`,\n -- until the section ends\n open Combinator.Calculus\n\n theorem SKx_eq_K : S K x = I := rfl\nend\n\n-- open everything under `Combinator.Calculus` only for the next command (the next `theorem`, here)\nopen Combinator.Calculus in\ntheorem SKx_eq_K' : S K x = I := rfl\n\nsection\n -- open only `S` and `K` under `Combinator.Calculus`\n open Combinator.Calculus (S K)\n\n theorem SKxy_eq_y : S K x y = y := rfl\n\n -- `I` is not in scope, we have to use its full path\n theorem SKxy_eq_Iy : S K x y = Combinator.Calculus.I y := rfl\nend\n\nsection\n open Combinator.Calculus\n renaming\n I → identity,\n K → konstant\n\n #check identity\n #check konstant\nend\n\nsection\n open Combinator.Calculus\n hiding S\n\n #check I\n #check K\nend\n\nsection\n namespace Demo\n inductive MyType\n | val\n\n namespace N1\n scoped infix:68 \" ≋ \" => BEq.beq\n\n scoped instance : BEq MyType where\n beq _ _ := true\n\n def Alias := MyType\n end N1\n end Demo\n\n -- bring `≋` and the instance in scope, but not `Alias`\n open scoped Demo.N1\n\n #check Demo.MyType.val == Demo.MyType.val\n #check Demo.MyType.val ≋ Demo.MyType.val\n -- #check Alias -- unknown identifier 'Alias'\nend\n```\n","name":["Lean","Parser","Command","open"],"occurrence":"Lean.Parser.Command.open-2713"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Verso.Output.TeX","kind":"unknown"}}},{"text":{"str":"\n\n"}},{"token":{"tok":{"content":"def","kind":{"keyword":{"docs":null,"name":["Lean","Parser","Command","definition"],"occurrence":"Lean.Parser.Command.definition-2736"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"mkList","kind":{"const":{"docs":null,"isDef":true,"name":["mkList"],"signature":"mkList (xs : List TeX) : TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"xs","kind":{"var":{"name":"_uniq.3","type":"List TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TeX","kind":{"const":{"docs":"TeX output\n","isDef":false,"name":["Verso","Output","TeX"],"signature":"Verso.Output.TeX : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"\\TeX{","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"\\begin{","kind":"unknown"}}},{"token":{"tok":{"content":"itemize","kind":"unknown"}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"\\Lean{","kind":"unknown"}}},{"token":{"tok":{"content":"xs","kind":{"var":{"name":"_uniq.3","type":"List TeX"}}}}},{"token":{"tok":{"content":".","kind":"unknown"}}},{"token":{"tok":{"content":"map","kind":{"const":{"docs":"Applies a function to each element of the list, returning the resulting list of values.\n\n`O(|l|)`.\n\nExamples:\n* `[a, b, c].map f = [f a, f b, f c]`\n* `[].map Nat.succ = []`\n* `[\"one\", \"two\", \"three\"].map (·.length) = [3, 3, 5]`\n* `[\"one\", \"two\", \"three\"].map (·.reverse) = [\"eno\", \"owt\", \"eerht\"]`\n","isDef":false,"name":["List","map"],"signature":"List.map.{u_1, u_2} {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) : List β"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"\\TeX{","kind":"unknown"}}},{"token":{"tok":{"content":"\\","kind":"unknown"}}},{"token":{"tok":{"content":"item","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"\" \"","kind":{"str":{"string":" "}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"\\Lean{","kind":"unknown"}}},{"token":{"tok":{"content":"·","kind":"unknown"}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"\"\\n\"","kind":{"str":{"string":"\n"}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"\\end{","kind":"unknown"}}},{"token":{"tok":{"content":"itemize","kind":"unknown"}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n\n"}},{"span":{"content":{"token":{"tok":{"content":"#eval","kind":{"keyword":{"docs":"`#eval e` evaluates the expression `e` by compiling and evaluating it.\n\n* The command attempts to use `ToExpr`, `Repr`, or `ToString` instances to print the result.\n* If `e` is a monadic value of type `m ty`, then the command tries to adapt the monad `m`\n to one of the monads that `#eval` supports, which include `IO`, `CoreM`, `MetaM`, `TermElabM`, and `CommandElabM`.\n Users can define `MonadEval` instances to extend the list of supported monads.\n\nThe `#eval` command gracefully degrades in capability depending on what is imported.\nImporting the `Lean.Elab.Command` module provides full capabilities.\n\nDue to unsoundness, `#eval` refuses to evaluate expressions that depend on `sorry`, even indirectly,\nsince the presence of `sorry` can lead to runtime instability and crashes.\nThis check can be overridden with the `#eval! e` command.\n\nOptions:\n* If `eval.pp` is true (default: true) then tries to use `ToExpr` instances to make use of the\n usual pretty printer. Otherwise, only tries using `Repr` and `ToString` instances.\n* If `eval.type` is true (default: false) then pretty prints the type of the evaluated value.\n* If `eval.derive.repr` is true (default: true) then attempts to auto-derive a `Repr` instance\n when there is no other way to print the result.\n\nSee also: `#reduce e` for evaluation by term reduction.\n","name":["Lean","Parser","Command","eval"],"occurrence":"Lean.Parser.Command.eval-2876"}}}}},"info":[["info",{"append":[{"text":""},{"text":"\\begin{itemize}\n\\item A\n\\item \\emph{B}\n\\item C\n\n\\end{itemize}\n\n"}]}]]}},{"text":{"str":" "}},{"token":{"tok":{"content":"mkList","kind":{"const":{"docs":null,"isDef":false,"name":["mkList"],"signature":"mkList (xs : List TeX) : TeX"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"\"A\"","kind":{"str":{"string":"A"}}}}},{"token":{"tok":{"content":",","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"\\TeX{","kind":"unknown"}}},{"token":{"tok":{"content":"\\","kind":"unknown"}}},{"token":{"tok":{"content":"emph","kind":"unknown"}}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"\"B\"","kind":{"str":{"string":"B"}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"token":{"tok":{"content":",","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"\"C\"","kind":{"str":{"string":"C"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"|>.","kind":"unknown"}}},{"token":{"tok":{"content":"asString","kind":{"const":{"docs":"Converts a TeX document to a string to be processed by LaTeX ","isDef":false,"name":["Verso","Output","TeX","asString"],"signature":"Verso.Output.TeX.asString (doc : TeX) : String"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"|>","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO.println","kind":{"const":{"docs":"Converts `s` to a string using its `ToString α` instance, and prints it with a trailing newline to\nthe current standard output (as determined by `IO.getStdout`).\n","isDef":false,"name":["IO","println"],"signature":"IO.println.{u_1} {α : Type u_1} [ToString α] (s : α) : IO Unit"}}}}},{"text":{"str":"\n"}},{"token":{"tok":{"content":"","kind":"unknown"}}}]}},[["mkList","mkList"]],"/home/runner/work/verso/verso/doc/UsersGuide/Output.lean",{"end":{"character":0,"line":115},"start":{"character":0,"line":103}}],"id":268,"name":"Verso.Genre.Manual.InlineLean.Block.lean","properties":{}},"content":[{"code":"open Verso.Output.TeX\n\ndef mkList (xs : List TeX) : TeX :=\n \\TeX{\n \\begin{itemize}\n \\Lean{xs.map (\\TeX{\\item \" \" \\Lean{·} \"\\n\"})}\n \\end{itemize}\n }\n\n#eval mkList [\"A\", \\TeX{\\emph{\"B\"}}, \"C\"]\n |>.asString\n |> IO.println\n"}]}}]},{"concat":[{"other":{"container":{"data":[{"contents":{"append":[{"text":""},{"append":[{"text":""},{"text":"\\begin{itemize}\n\\item A\n\\item \\emph{B}\n\\item C\n\n\\end{itemize}\n\n"}]}]},"severity":"info"},[false,[]]],"id":270,"name":"Verso.Genre.Manual.InlineLean.Block.leanOutput","properties":{}},"content":[{"code":"\\begin{itemize}\n\\item A\n\\item \\emph{B}\n\\item C\n\n\\end{itemize}\n"}]}}]}],"metadata":{"assignedNumber":2,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":255,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"output-tex"}}},"subParts":[],"title":[{"text":"TeX"}],"titleString":"TeX"}],"title":[{"text":"Output Formats"}],"titleString":"Output Formats"},{"content":[{"para":[{"text":"Verso's website genre is a static site generator."},{"linebreak":"\n"},{"text":"It contains two Verso "},{"other":{"container":{"data":{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}},"id":272,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Genre"}]}},{"text":"s: "},{"other":{"container":{"data":{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},"id":273,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Page"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Post","kind":{"const":{"docs":"A blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Post"],"signature":"Verso.Genre.Blog.Post : Genre"}}}}},"id":274,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Post"}]}},{"text":", which are identical except for their metadata:"}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Page",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Page","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Page","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}}},[null,[]]]]],"id":275,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"An ordinary web page that is not a blog post."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Post",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Post","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Post","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}}},[null,[]]]]],"id":276,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A blog post."}]}]}}]},{"para":[{"text":"Both feature the same set of extensions:"}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.BlockExt",[{"inductive":{"constructors":[{"docstring":"Highlighted Lean code.\n","hlName":{"token":{"tok":{"content":"highlightedCode","kind":{"const":{"docs":"Highlighted Lean code.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","highlightedCode"],"signature":"Verso.Genre.Blog.BlockExt.highlightedCode (opts : Blog.CodeOpts) (highlighted : SubVerso.Highlighting.Highlighted) :\n Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.highlightedCode","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"highlightedCode","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"opts","kind":{"var":{"name":"_uniq.11","type":"Blog.CodeOpts"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.CodeOpts","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","CodeOpts"],"signature":"Verso.Genre.Blog.CodeOpts : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"highlighted","kind":{"var":{"name":"_uniq.12","type":"SubVerso.Highlighting.Highlighted"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted"],"signature":"SubVerso.Highlighting.Highlighted : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"Highlighted Lean messages.\n","hlName":{"token":{"tok":{"content":"message","kind":{"const":{"docs":"Highlighted Lean messages.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","message"],"signature":"Verso.Genre.Blog.BlockExt.message (summarize : Bool) (msg : SubVerso.Highlighting.Highlighted.Message)\n (expandTraces : List Lean.Name) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.message","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"message","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"summarize","kind":{"var":{"name":"_uniq.13","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"msg","kind":{"var":{"name":"_uniq.14","type":"SubVerso.Highlighting.Highlighted.Message"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted.Message","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted","Message"],"signature":"SubVerso.Highlighting.Highlighted.Message : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"expandTraces","kind":{"var":{"name":"_uniq.15","type":"List Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"Lexed text, to be displayed with highlighted syntax.\n","hlName":{"token":{"tok":{"content":"lexedText","kind":{"const":{"docs":"Lexed text, to be displayed with highlighted syntax.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","lexedText"],"signature":"Verso.Genre.Blog.BlockExt.lexedText (content : Blog.LexedText) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.lexedText","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"lexedText","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"content","kind":{"var":{"name":"_uniq.16","type":"Blog.LexedText"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.LexedText","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","LexedText"],"signature":"Verso.Genre.Blog.LexedText : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"When rendered, the content is wrapped in a `` with the given classes.\n","hlName":{"token":{"tok":{"content":"htmlDiv","kind":{"const":{"docs":"When rendered, the content is wrapped in a `
` with the given classes.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","htmlDiv"],"signature":"Verso.Genre.Blog.BlockExt.htmlDiv (classes : String) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.htmlDiv","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlDiv","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"classes","kind":{"var":{"name":"_uniq.17","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"When rendered, the content is wrapped in the specified HTML tag.\n","hlName":{"token":{"tok":{"content":"htmlWrapper","kind":{"const":{"docs":"When rendered, the content is wrapped in the specified HTML tag.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","htmlWrapper"],"signature":"Verso.Genre.Blog.BlockExt.htmlWrapper (tag : String) (attributes : Array (String × String)) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.htmlWrapper","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlWrapper","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"tag","kind":{"var":{"name":"_uniq.18","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"attributes","kind":{"var":{"name":"_uniq.19","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"When rendered, the content is wrapped in a `
` tag with the given summary.\n","hlName":{"token":{"tok":{"content":"htmlDetails","kind":{"const":{"docs":"When rendered, the content is wrapped in a `` tag with the given summary.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","htmlDetails"],"signature":"Verso.Genre.Blog.BlockExt.htmlDetails (classes : String) (summary : Output.Html) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.htmlDetails","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlDetails","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"classes","kind":{"var":{"name":"_uniq.20","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"summary","kind":{"var":{"name":"_uniq.21","type":"Output.Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"A blob of HTML. The contents are discarded.\n","hlName":{"token":{"tok":{"content":"blob","kind":{"const":{"docs":"A blob of HTML. The contents are discarded.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","blob"],"signature":"Verso.Genre.Blog.BlockExt.blob (html : Output.Html) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.blob","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"blob","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.22","type":"Output.Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"A reference to a component.\n","hlName":{"token":{"tok":{"content":"component","kind":{"const":{"docs":"A reference to a component.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","component"],"signature":"Verso.Genre.Blog.BlockExt.component (name : Lean.Name) (data : Lean.Json) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.component","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"component","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.23","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"data","kind":{"var":{"name":"_uniq.24","type":"Lean.Json"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"A Lean docstring that was indented `indent` spaces in the original source.\n","hlName":{"token":{"tok":{"content":"docstring","kind":{"const":{"docs":"A Lean docstring that was indented `indent` spaces in the original source.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","docstring"],"signature":"Verso.Genre.Blog.BlockExt.docstring (indent : Nat) (declName? : Option Lean.Name) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.docstring","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"docstring","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"indent","kind":{"var":{"name":"_uniq.25","type":"Nat"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Nat","kind":{"const":{"docs":"The natural numbers, starting at zero.\n\nThis type is special-cased by both the kernel and the compiler, and overridden with an efficient\nimplementation. Both use a fast arbitrary-precision arithmetic library (usually\n[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.\n","isDef":false,"name":["Nat"],"signature":"Nat : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"declName?","kind":{"var":{"name":"_uniq.26","type":"Option Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}},{"docstring":"A section in a Lean docstring.\n\nLean docstrings may contain nested headers, but they are not sections of the document as a whole.\nThe contents of a docstring section are expected to be a paragraph that contains the section's\ntitle, followed by the actual content.\n","hlName":{"token":{"tok":{"content":"docstringSection","kind":{"const":{"docs":"A section in a Lean docstring.\n\nLean docstrings may contain nested headers, but they are not sections of the document as a whole.\nThe contents of a docstring section are expected to be a paragraph that contains the section's\ntitle, followed by the actual content.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt","docstringSection"],"signature":"Verso.Genre.Blog.BlockExt.docstringSection (level : Nat) : Blog.BlockExt"}}}}},"name":"Verso.Genre.Blog.BlockExt.docstringSection","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"docstringSection","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"level","kind":{"var":{"name":"_uniq.27","type":"Nat"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Nat","kind":{"const":{"docs":"The natural numbers, starting at zero.\n\nThis type is special-cased by both the kernel and the compiler, and overridden with an efficient\nimplementation. Both use a fast arbitrary-precision arithmetic library (usually\n[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.\n","isDef":false,"name":["Nat"],"signature":"Nat : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.BlockExt","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.BlockExt","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":277,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"The additional blocks available in pages and posts."}]},{"other":{"container":{"data":"Constructors","id":278,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"highlightedCode","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"opts","kind":{"var":{"name":"_uniq.11","type":"Blog.CodeOpts"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.CodeOpts","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","CodeOpts"],"signature":"Verso.Genre.Blog.CodeOpts : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"highlighted","kind":{"var":{"name":"_uniq.12","type":"SubVerso.Highlighting.Highlighted"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted"],"signature":"SubVerso.Highlighting.Highlighted : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":279,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Highlighted Lean code."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"message","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"summarize","kind":{"var":{"name":"_uniq.13","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"msg","kind":{"var":{"name":"_uniq.14","type":"SubVerso.Highlighting.Highlighted.Message"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted.Message","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted","Message"],"signature":"SubVerso.Highlighting.Highlighted.Message : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"expandTraces","kind":{"var":{"name":"_uniq.15","type":"List Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":280,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Highlighted Lean messages."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"lexedText","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"content","kind":{"var":{"name":"_uniq.16","type":"Blog.LexedText"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.LexedText","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","LexedText"],"signature":"Verso.Genre.Blog.LexedText : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":281,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Lexed text, to be displayed with highlighted syntax."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlDiv","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"classes","kind":{"var":{"name":"_uniq.17","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":282,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"When rendered, the content is wrapped in a "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"div","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":283,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" with the given classes."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlWrapper","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"tag","kind":{"var":{"name":"_uniq.18","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"attributes","kind":{"var":{"name":"_uniq.19","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":284,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"When rendered, the content is wrapped in the specified HTML tag."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlDetails","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"classes","kind":{"var":{"name":"_uniq.20","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"summary","kind":{"var":{"name":"_uniq.21","type":"Output.Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":285,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"When rendered, the content is wrapped in a "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"details","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":286,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" tag with the given summary."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"blob","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.22","type":"Output.Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":287,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A blob of HTML. The contents are discarded."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"component","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.23","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"data","kind":{"var":{"name":"_uniq.24","type":"Lean.Json"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":288,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A reference to a component."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"docstring","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"indent","kind":{"var":{"name":"_uniq.25","type":"Nat"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Nat","kind":{"const":{"docs":"The natural numbers, starting at zero.\n\nThis type is special-cased by both the kernel and the compiler, and overridden with an efficient\nimplementation. Both use a fast arbitrary-precision arithmetic library (usually\n[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.\n","isDef":false,"name":["Nat"],"signature":"Nat : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"declName?","kind":{"var":{"name":"_uniq.26","type":"Option Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":289,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A Lean docstring that was indented "},{"other":{"container":{"data":{"token":{"tok":{"content":"indent","kind":{"var":{"name":"_uniq.42","type":"Nat"}}}}},"id":290,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"indent"}]}},{"text":" spaces in the original source."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"docstringSection","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"level","kind":{"var":{"name":"_uniq.27","type":"Nat"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Nat","kind":{"const":{"docs":"The natural numbers, starting at zero.\n\nThis type is special-cased by both the kernel and the compiler, and overridden with an efficient\nimplementation. Both use a fast arbitrary-precision arithmetic library (usually\n[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.\n","isDef":false,"name":["Nat"],"signature":"Nat : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlockExt","kind":{"const":{"docs":"The additional blocks available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","BlockExt"],"signature":"Verso.Genre.Blog.BlockExt : Type"}}}}}]}},"id":291,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A section in a Lean docstring."}]},{"para":[{"text":"Lean docstrings may contain nested headers, but they are not sections of the document as a whole."},{"text":"\n"},{"text":"The contents of a docstring section are expected to be a paragraph that contains the section's"},{"text":"\n"},{"text":"title, followed by the actual content."}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.InlineExt",[{"inductive":{"constructors":[{"docstring":"Highlighted Lean code.\n","hlName":{"token":{"tok":{"content":"highlightedCode","kind":{"const":{"docs":"Highlighted Lean code.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","highlightedCode"],"signature":"Verso.Genre.Blog.InlineExt.highlightedCode (opts : Blog.CodeOpts) (highlighted : SubVerso.Highlighting.Highlighted) :\n Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.highlightedCode","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"highlightedCode","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"opts","kind":{"var":{"name":"_uniq.47","type":"Blog.CodeOpts"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.CodeOpts","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","CodeOpts"],"signature":"Verso.Genre.Blog.CodeOpts : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"highlighted","kind":{"var":{"name":"_uniq.48","type":"SubVerso.Highlighting.Highlighted"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted"],"signature":"SubVerso.Highlighting.Highlighted : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"Highlighted Lean messages.\n","hlName":{"token":{"tok":{"content":"message","kind":{"const":{"docs":"Highlighted Lean messages.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","message"],"signature":"Verso.Genre.Blog.InlineExt.message (msg : SubVerso.Highlighting.Highlighted.Message) (expandTraces : List Lean.Name) :\n Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.message","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"message","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"msg","kind":{"var":{"name":"_uniq.49","type":"SubVerso.Highlighting.Highlighted.Message"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted.Message","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted","Message"],"signature":"SubVerso.Highlighting.Highlighted.Message : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"expandTraces","kind":{"var":{"name":"_uniq.50","type":"List Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"Lexed text, to be displayed with highlighted syntax.\n","hlName":{"token":{"tok":{"content":"lexedText","kind":{"const":{"docs":"Lexed text, to be displayed with highlighted syntax.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","lexedText"],"signature":"Verso.Genre.Blog.InlineExt.lexedText (content : Blog.LexedText) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.lexedText","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"lexedText","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"content","kind":{"var":{"name":"_uniq.51","type":"Blog.LexedText"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.LexedText","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","LexedText"],"signature":"Verso.Genre.Blog.LexedText : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"Highlighted code that is not necessarily from Lean.\n","hlName":{"token":{"tok":{"content":"customHighlight","kind":{"const":{"docs":"Highlighted code that is not necessarily from Lean.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","customHighlight"],"signature":"Verso.Genre.Blog.InlineExt.customHighlight (highlighted : SubVerso.Highlighting.Highlighted) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.customHighlight","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"customHighlight","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"highlighted","kind":{"var":{"name":"_uniq.52","type":"SubVerso.Highlighting.Highlighted"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted"],"signature":"SubVerso.Highlighting.Highlighted : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"A label to serve as a cross-reference target.\n","hlName":{"token":{"tok":{"content":"label","kind":{"const":{"docs":"A label to serve as a cross-reference target.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","label"],"signature":"Verso.Genre.Blog.InlineExt.label (name : Lean.Name) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.label","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"label","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.53","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"A reference to a label.\n","hlName":{"token":{"tok":{"content":"ref","kind":{"const":{"docs":"A reference to a label.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","ref"],"signature":"Verso.Genre.Blog.InlineExt.ref (name : Lean.Name) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.ref","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"ref","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.54","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"A reference to a page or post's internal name as a Lean value, to be shown as a link.\nIf `id?` is `some X`, then the link is suffixed with `#X`.\n","hlName":{"token":{"tok":{"content":"pageref","kind":{"const":{"docs":"A reference to a page or post's internal name as a Lean value, to be shown as a link.\nIf `id?` is `some X`, then the link is suffixed with `#X`.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","pageref"],"signature":"Verso.Genre.Blog.InlineExt.pageref (name : Lean.Name) (id? : Option String) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.pageref","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"pageref","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.55","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id?","kind":{"var":{"name":"_uniq.56","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"An HTML span element with the given classes.\n","hlName":{"token":{"tok":{"content":"htmlSpan","kind":{"const":{"docs":"An HTML span element with the given classes.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","htmlSpan"],"signature":"Verso.Genre.Blog.InlineExt.htmlSpan (classes : String) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.htmlSpan","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlSpan","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"classes","kind":{"var":{"name":"_uniq.57","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"A blob of HTML. The contents are discarded.\n","hlName":{"token":{"tok":{"content":"blob","kind":{"const":{"docs":"A blob of HTML. The contents are discarded.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","blob"],"signature":"Verso.Genre.Blog.InlineExt.blob (html : Output.Html) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.blob","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"blob","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.58","type":"Output.Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}},{"docstring":"A reference to a component.\n","hlName":{"token":{"tok":{"content":"component","kind":{"const":{"docs":"A reference to a component.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt","component"],"signature":"Verso.Genre.Blog.InlineExt.component (name : Lean.Name) (data : Lean.Json) : Blog.InlineExt"}}}}},"name":"Verso.Genre.Blog.InlineExt.component","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"component","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.59","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"data","kind":{"var":{"name":"_uniq.60","type":"Lean.Json"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.InlineExt","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.InlineExt","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":292,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"The additional inline elements available in pages and posts."}]},{"other":{"container":{"data":"Constructors","id":293,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"highlightedCode","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"opts","kind":{"var":{"name":"_uniq.47","type":"Blog.CodeOpts"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.CodeOpts","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","CodeOpts"],"signature":"Verso.Genre.Blog.CodeOpts : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"highlighted","kind":{"var":{"name":"_uniq.48","type":"SubVerso.Highlighting.Highlighted"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted"],"signature":"SubVerso.Highlighting.Highlighted : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":294,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Highlighted Lean code."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"message","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"msg","kind":{"var":{"name":"_uniq.49","type":"SubVerso.Highlighting.Highlighted.Message"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted.Message","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted","Message"],"signature":"SubVerso.Highlighting.Highlighted.Message : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"expandTraces","kind":{"var":{"name":"_uniq.50","type":"List Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":295,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Highlighted Lean messages."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"lexedText","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"content","kind":{"var":{"name":"_uniq.51","type":"Blog.LexedText"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.LexedText","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","LexedText"],"signature":"Verso.Genre.Blog.LexedText : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":296,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Lexed text, to be displayed with highlighted syntax."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"customHighlight","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"highlighted","kind":{"var":{"name":"_uniq.52","type":"SubVerso.Highlighting.Highlighted"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"SubVerso.Highlighting.Highlighted","kind":{"const":{"docs":null,"isDef":false,"name":["SubVerso","Highlighting","Highlighted"],"signature":"SubVerso.Highlighting.Highlighted : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":297,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Highlighted code that is not necessarily from Lean."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"label","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.53","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":298,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A label to serve as a cross-reference target."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"ref","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.54","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":299,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A reference to a label."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"pageref","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.55","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id?","kind":{"var":{"name":"_uniq.56","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":300,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A reference to a page or post's internal name as a Lean value, to be shown as a link."},{"text":"\n"},{"text":"If "},{"other":{"container":{"data":{"token":{"tok":{"content":"id?","kind":{"var":{"name":"_uniq.70","type":"Option String"}}}}},"id":301,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"id?"}]}},{"text":" is "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"some","kind":{"const":{"docs":"Some value of type `α`. ","isDef":false,"name":["Option","some"],"signature":"Option.some.{u} {α : Type u} (val : α) : Option α"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"X","kind":{"var":{"name":"_uniq.78","type":"?m.1"}}}}}]}},"id":302,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"some X"}]}},{"text":", then the link is suffixed with "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"#","kind":"unknown"}}},{"token":{"tok":{"content":"X","kind":"unknown"}}}]}},"id":303,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"#X"}]}},{"text":"."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"htmlSpan","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"classes","kind":{"var":{"name":"_uniq.57","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":304,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"An HTML span element with the given classes."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"blob","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":{"var":{"name":"_uniq.58","type":"Output.Html"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":305,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A blob of HTML. The contents are discarded."}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"component","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.59","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"data","kind":{"var":{"name":"_uniq.60","type":"Lean.Json"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.InlineExt","kind":{"const":{"docs":"The additional inline elements available in pages and posts.\n","isDef":false,"name":["Verso","Genre","Blog","InlineExt"],"signature":"Verso.Genre.Blog.InlineExt : Type"}}}}}]}},"id":306,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"A reference to a component."}]}]}}]}}]}}]},{"para":[{"text":"However, their metadata are different:"}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Page.Meta",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Blog.Page.Meta.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Page","Meta","mk"],"signature":"Verso.Genre.Blog.Page.Meta.mk (showInNav : Bool) (htmlId : Option String) : Page.Meta"}}}}},"name":"Verso.Genre.Blog.Page.Meta.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Page.Meta.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"showInNav","kind":{"var":{"name":"_uniq.89","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmlId","kind":{"var":{"name":"_uniq.90","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page.Meta","kind":{"const":{"docs":"The metadata used for non-blog-post pages ","isDef":false,"name":["Verso","Genre","Blog","Page","Meta"],"signature":"Verso.Genre.Blog.Page.Meta : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"Whether to hide this page/part from navigation entries ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"showInNav","kind":{"const":{"docs":"Whether to hide this page/part from navigation entries ","isDef":true,"name":["Verso","Genre","Blog","Page","Meta","showInNav"],"signature":"Bool"}}}}},"projFn":"Verso.Genre.Blog.Page.Meta.showInNav","type":{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The HTML ID to assign to the header ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"htmlId","kind":{"const":{"docs":"The HTML ID to assign to the header ","isDef":true,"name":["Verso","Genre","Blog","Page","Meta","htmlId"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Blog.Page.Meta.htmlId","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["showInNav","htmlId"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Page.Meta","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Page.Meta","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":307,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"The metadata used for non-blog-post pages"}]},{"other":{"container":{"data":"Constructor","id":308,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Blog.Page.Meta.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Page","Meta","mk"],"signature":"Verso.Genre.Blog.Page.Meta.mk (showInNav : Bool) (htmlId : Option String) : Page.Meta"}}}}},null],"id":309,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":310,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"showInNav","kind":{"const":{"docs":"Whether to hide this page/part from navigation entries ","isDef":true,"name":["Verso","Genre","Blog","Page","Meta","showInNav"],"signature":"Bool"}}}}},[{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},[null,[]]]]],"id":311,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Whether to hide this page/part from navigation entries"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"htmlId","kind":{"const":{"docs":"The HTML ID to assign to the header ","isDef":true,"name":["Verso","Genre","Blog","Page","Meta","htmlId"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":312,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The HTML ID to assign to the header"}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Post.Meta",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Blog.Post.Meta.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Post","Meta","mk"],"signature":"Verso.Genre.Blog.Post.Meta.mk (date : Blog.Date) (authors : List String) (categories : List Post.Category)\n (draft : Bool) (htmlId : Option String) : Post.Meta"}}}}},"name":"Verso.Genre.Blog.Post.Meta.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Post.Meta.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"date","kind":{"var":{"name":"_uniq.98","type":"Blog.Date"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Date","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Date"],"signature":"Verso.Genre.Blog.Date : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"authors","kind":{"var":{"name":"_uniq.99","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"categories","kind":{"var":{"name":"_uniq.100","type":"List Post.Category"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Post.Category","kind":{"const":{"docs":"A category of blog posts.\n","isDef":false,"name":["Verso","Genre","Blog","Post","Category"],"signature":"Verso.Genre.Blog.Post.Category : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"draft","kind":{"var":{"name":"_uniq.101","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmlId","kind":{"var":{"name":"_uniq.102","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Post.Meta","kind":{"const":{"docs":"The metadata used for blog posts ","isDef":false,"name":["Verso","Genre","Blog","Post","Meta"],"signature":"Verso.Genre.Blog.Post.Meta : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"The post's date. By default, this is used in the URL as well as included in the content. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"date","kind":{"const":{"docs":"The post's date. By default, this is used in the URL as well as included in the content. ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","date"],"signature":"Blog.Date"}}}}},"projFn":"Verso.Genre.Blog.Post.Meta.date","type":{"token":{"tok":{"content":"Blog.Date","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Date"],"signature":"Verso.Genre.Blog.Date : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The authors of the post ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"authors","kind":{"const":{"docs":"The authors of the post ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","authors"],"signature":"List String"}}}}},"projFn":"Verso.Genre.Blog.Post.Meta.authors","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The categories in which to include the post ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"categories","kind":{"const":{"docs":"The categories in which to include the post ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","categories"],"signature":"List Post.Category"}}}}},"projFn":"Verso.Genre.Blog.Post.Meta.categories","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Post.Category","kind":{"const":{"docs":"A category of blog posts.\n","isDef":false,"name":["Verso","Genre","Blog","Post","Category"],"signature":"Verso.Genre.Blog.Post.Category : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"If `true`, the post is not rendered by default ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"draft","kind":{"const":{"docs":"If `true`, the post is not rendered by default ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","draft"],"signature":"Bool"}}}}},"projFn":"Verso.Genre.Blog.Post.Meta.draft","type":{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The HTML ID to assign to the header ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"htmlId","kind":{"const":{"docs":"The HTML ID to assign to the header ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","htmlId"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Blog.Post.Meta.htmlId","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["date","authors","categories","draft","htmlId"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Post.Meta","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Post.Meta","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":313,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"The metadata used for blog posts"}]},{"other":{"container":{"data":"Constructor","id":314,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Blog.Post.Meta.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Post","Meta","mk"],"signature":"Verso.Genre.Blog.Post.Meta.mk (date : Blog.Date) (authors : List String) (categories : List Post.Category)\n (draft : Bool) (htmlId : Option String) : Post.Meta"}}}}},null],"id":315,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":316,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"date","kind":{"const":{"docs":"The post's date. By default, this is used in the URL as well as included in the content. ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","date"],"signature":"Blog.Date"}}}}},[{"token":{"tok":{"content":"Blog.Date","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Date"],"signature":"Verso.Genre.Blog.Date : Type"}}}}},[null,[]]]]],"id":317,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The post's date. By default, this is used in the URL as well as included in the content."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"authors","kind":{"const":{"docs":"The authors of the post ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","authors"],"signature":"List String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":318,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The authors of the post"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"categories","kind":{"const":{"docs":"The categories in which to include the post ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","categories"],"signature":"List Post.Category"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Post.Category","kind":{"const":{"docs":"A category of blog posts.\n","isDef":false,"name":["Verso","Genre","Blog","Post","Category"],"signature":"Verso.Genre.Blog.Post.Category : Type"}}}}}]}},[null,[]]]]],"id":319,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The categories in which to include the post"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"draft","kind":{"const":{"docs":"If `true`, the post is not rendered by default ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","draft"],"signature":"Bool"}}}}},[{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},[null,[]]]]],"id":320,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"If "},{"other":{"container":{"data":{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},"id":321,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"true"}]}},{"text":", the post is not rendered by default"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"htmlId","kind":{"const":{"docs":"The HTML ID to assign to the header ","isDef":true,"name":["Verso","Genre","Blog","Post","Meta","htmlId"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":322,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The HTML ID to assign to the header"}]}]}}]}}]}}]}],"metadata":{"assignedNumber":6,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"never","htmlToc":true,"id":271,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"website"}}},"subParts":[{"content":[{"para":[{"text":"Blogs should have an executable that invokes "},{"code":"blogMain"},{"text":" on the appropriate "},{"other":{"container":{"data":{"canonicalName":"site-config","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Websites/#site-config"},"id":628,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"site and theme"}]}},{"text":", forwarding on command-line arguments."},{"linebreak":"\n"},{"text":"It is responsible for "},{"other":{"container":{"data":{"canonicalName":"traversal","domain":"Verso.Genre.Manual.section","remote":null,"resolvedDestination":"/Building-Documents/Traversal/#traversal"},"id":617,"name":"Verso.Genre.Manual.Inline.ref"},"content":[{"text":"traversing"}]}},{"text":" the site and generating the HTML."}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.blogMain",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.blogMain","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"theme","kind":{"var":{"name":"_uniq.167","type":"Blog.Theme"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Theme","kind":{"const":{"docs":"A specification of how to render a site.\n","isDef":false,"name":["Verso","Genre","Blog","Theme"],"signature":"Verso.Genre.Blog.Theme : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"site","kind":{"var":{"name":"_uniq.168","type":"Blog.Site"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"linkTargets","kind":{"var":{"name":"_uniq.170","type":"optParam (Code.LinkTargets Blog.TraverseContext) { }"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Code.LinkTargets","kind":{"const":{"docs":"Instructions for computing link targets for various code elements.\n\nEach kind of link may have multiple destinations. The first is the default link, while the remainder\nare considered alternates.\n","isDef":false,"name":["Verso","Code","LinkTargets"],"signature":"Verso.Code.LinkTargets (Ctxt : Type) : Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.TraverseContext","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","TraverseContext"],"signature":"Verso.Genre.Blog.TraverseContext : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Code","LinkTargets","mk"],"signature":"Verso.Code.LinkTargets.mk {Ctxt : Type} (var : Lean.FVarId → Option Ctxt → Array Code.CodeLink)\n (sort : Lean.Level → Option Ctxt → Array Code.CodeLink)\n (const option keyword definition moduleName : Lean.Name → Option Ctxt → Array Code.CodeLink) : Code.LinkTargets Ctxt"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"}","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Code","LinkTargets","mk"],"signature":"Verso.Code.LinkTargets.mk {Ctxt : Type} (var : Lean.FVarId → Option Ctxt → Array Code.CodeLink)\n (sort : Lean.Level → Option Ctxt → Array Code.CodeLink)\n (const option keyword definition moduleName : Lean.Name → Option Ctxt → Array Code.CodeLink) : Code.LinkTargets Ctxt"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"options","kind":{"var":{"name":"_uniq.171","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"components","kind":{"var":{"name":"_uniq.172","type":"autoParam Blog.Components Blog.blogMain._auto_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Components","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Components"],"signature":"Verso.Genre.Blog.Components : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"by","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"exact","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"%registered_components)","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"header","kind":{"var":{"name":"_uniq.173","type":"optParam String Output.Html.doctype"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Output.Html.doctype","kind":{"const":{"docs":"The default `DOCTYPE` for HTML5. ","isDef":false,"name":["Verso","Output","Html","doctype"],"signature":"Verso.Output.Html.doctype : String"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"UInt32","kind":{"const":{"docs":"Unsigned 32-bit integers.\n\nThis type has special support in the compiler so it can be represented by an unboxed 32-bit value\nrather than wrapping a `BitVec 32`.\n","isDef":false,"name":["UInt32"],"signature":"UInt32 : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.blogMain","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"theme","kind":{"var":{"name":"_uniq.167","type":"Blog.Theme"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Theme","kind":{"const":{"docs":"A specification of how to render a site.\n","isDef":false,"name":["Verso","Genre","Blog","Theme"],"signature":"Verso.Genre.Blog.Theme : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"site","kind":{"var":{"name":"_uniq.168","type":"Blog.Site"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"linkTargets","kind":{"var":{"name":"_uniq.170","type":"optParam (Code.LinkTargets Blog.TraverseContext) { }"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Code.LinkTargets","kind":{"const":{"docs":"Instructions for computing link targets for various code elements.\n\nEach kind of link may have multiple destinations. The first is the default link, while the remainder\nare considered alternates.\n","isDef":false,"name":["Verso","Code","LinkTargets"],"signature":"Verso.Code.LinkTargets (Ctxt : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.TraverseContext","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","TraverseContext"],"signature":"Verso.Genre.Blog.TraverseContext : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Code","LinkTargets","mk"],"signature":"Verso.Code.LinkTargets.mk {Ctxt : Type} (var : Lean.FVarId → Option Ctxt → Array Code.CodeLink)\n (sort : Lean.Level → Option Ctxt → Array Code.CodeLink)\n (const option keyword definition moduleName : Lean.Name → Option Ctxt → Array Code.CodeLink) : Code.LinkTargets Ctxt"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"}","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Code","LinkTargets","mk"],"signature":"Verso.Code.LinkTargets.mk {Ctxt : Type} (var : Lean.FVarId → Option Ctxt → Array Code.CodeLink)\n (sort : Lean.Level → Option Ctxt → Array Code.CodeLink)\n (const option keyword definition moduleName : Lean.Name → Option Ctxt → Array Code.CodeLink) : Code.LinkTargets Ctxt"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"options","kind":{"var":{"name":"_uniq.171","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"components","kind":{"var":{"name":"_uniq.172","type":"autoParam Blog.Components Blog.blogMain._auto_1"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Components","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Components"],"signature":"Verso.Genre.Blog.Components : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"by","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"exact","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"%registered_components)","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"header","kind":{"var":{"name":"_uniq.173","type":"optParam String Output.Html.doctype"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html.doctype","kind":{"const":{"docs":"The default `DOCTYPE` for HTML5. ","isDef":false,"name":["Verso","Output","Html","doctype"],"signature":"Verso.Output.Html.doctype : String"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"UInt32","kind":{"const":{"docs":"Unsigned 32-bit integers.\n\nThis type has special support in the compiler so it can be represented by an unboxed 32-bit value\nrather than wrapping a `BitVec 32`.\n","isDef":false,"name":["UInt32"],"signature":"UInt32 : Type"}}}}}]}}},[null,[]]]]],"id":326,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Generates the HTML for "},{"other":{"container":{"data":{"token":{"tok":{"content":"site","kind":{"var":{"name":"_uniq.133","type":"Blog.Site"}}}}},"id":327,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"site"}]}},{"text":"."}]},{"para":[{"text":"Parameters:"}]},{"ul":[{"contents":[{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"theme","kind":{"var":{"name":"_uniq.146","type":"Blog.Theme"}}}}},"id":328,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"theme"}]}},{"text":" is the theme used to render content."}]}]},{"contents":[{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"site","kind":{"var":{"name":"_uniq.147","type":"Blog.Site"}}}}},"id":329,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"site"}]}},{"text":" is the site to be generated."}]}]},{"contents":[{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"options","kind":{"var":{"name":"_uniq.149","type":"List String"}}}}},"id":330,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"options"}]}},{"text":" are the command-line options provided by a user."}]}]}]},{"para":[{"text":"Optional parameters:"}]},{"ul":[{"contents":[{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"linkTargets","kind":{"var":{"name":"_uniq.162","type":"optParam (Code.LinkTargets Blog.TraverseContext) { }"}}}}},"id":331,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"linkTargets"}]}},{"text":" specifies how to create hyperlinks from Lean code to further documentation. By"},{"text":"\n"},{"text":"default, no links are generated."}]}]},{"contents":[{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"components","kind":{"var":{"name":"_uniq.164","type":"autoParam Blog.Components Blog.blogMain._auto_1"}}}}},"id":332,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"components"}]}},{"text":" contains the implementation of the components. This is automatically filled out from"},{"text":"\n"},{"text":"a table."}]}]},{"contents":[{"para":[{"other":{"container":{"data":{"token":{"tok":{"content":"header","kind":{"var":{"name":"_uniq.165","type":"optParam String Output.Html.doctype"}}}}},"id":333,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"header"}]}},{"text":" is emitted prior to each HTML document. By default, it produces a "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"doctype","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":334,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":", but it"},{"text":"\n"},{"text":"can be overridden to integrate with other static site generators."}]}]}]}]}}]}],"metadata":{"assignedNumber":1,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":323,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"blogMain"}}},"subParts":[],"title":[{"text":"Generating a Site"}],"titleString":"Generating a Site"},{"content":[{"para":[{"text":"The URL layout of a site is specified via a "},{"other":{"container":{"data":{"token":{"tok":{"content":"Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}},"id":336,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Site"}]}},{"text":":"}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Site",[{"inductive":{"constructors":[{"docstring":"The root of the site is a page ","hlName":{"token":{"tok":{"content":"page","kind":{"const":{"docs":"The root of the site is a page ","isDef":false,"name":["Verso","Genre","Blog","Site","page"],"signature":"Verso.Genre.Blog.Site.page (id : Lean.Name) (text : Part Page) (contents : Array Blog.Dir) : Blog.Site"}}}}},"name":"Verso.Genre.Blog.Site.page","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"page","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.178","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.180","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.181","type":"Array Blog.Dir"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}}]}}},{"docstring":"The root of the site is a blog with its associated posts ","hlName":{"token":{"tok":{"content":"blog","kind":{"const":{"docs":"The root of the site is a blog with its associated posts ","isDef":false,"name":["Verso","Genre","Blog","Site","blog"],"signature":"Verso.Genre.Blog.Site.blog (id : Lean.Name) (text : Part Page) (contents : Array Blog.BlogPost) : Blog.Site"}}}}},"name":"Verso.Genre.Blog.Site.blog","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"blog","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.182","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.184","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.185","type":"Array Blog.BlogPost"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlogPost","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","BlogPost"],"signature":"Verso.Genre.Blog.BlogPost : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Site","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Site","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":337,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A specification of the layout of an entire site"}]},{"other":{"container":{"data":"Constructors","id":338,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"page","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.178","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.180","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.181","type":"Array Blog.Dir"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}}]}},"id":339,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"The root of the site is a page"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"blog","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.182","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.184","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.185","type":"Array Blog.BlogPost"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlogPost","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","BlogPost"],"signature":"Verso.Genre.Blog.BlogPost : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Site","kind":{"const":{"docs":"A specification of the layout of an entire site ","isDef":false,"name":["Verso","Genre","Blog","Site"],"signature":"Verso.Genre.Blog.Site : Type"}}}}}]}},"id":340,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"The root of the site is a blog with its associated posts"}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Dir",[{"inductive":{"constructors":[{"docstring":"The directory's root is the provided page ","hlName":{"token":{"tok":{"content":"page","kind":{"const":{"docs":"The directory's root is the provided page ","isDef":false,"name":["Verso","Genre","Blog","Dir","page"],"signature":"Verso.Genre.Blog.Dir.page (name : String) (id : Lean.Name) (text : Part Page) (contents : Array Blog.Dir) : Blog.Dir"}}}}},"name":"Verso.Genre.Blog.Dir.page","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"page","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.193","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.194","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.196","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.197","type":"Array Blog.Dir"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}}]}}},{"docstring":"The directory's root is a blog ","hlName":{"token":{"tok":{"content":"blog","kind":{"const":{"docs":"The directory's root is a blog ","isDef":false,"name":["Verso","Genre","Blog","Dir","blog"],"signature":"Verso.Genre.Blog.Dir.blog (name : String) (id : Lean.Name) (text : Part Page) (contents : Array Blog.BlogPost) :\n Blog.Dir"}}}}},"name":"Verso.Genre.Blog.Dir.blog","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"blog","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.198","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.199","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.201","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.202","type":"Array Blog.BlogPost"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlogPost","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","BlogPost"],"signature":"Verso.Genre.Blog.BlogPost : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}}]}}},{"docstring":"The directory's root contains static files, copied from `files` when the site is generated ","hlName":{"token":{"tok":{"content":"static","kind":{"const":{"docs":"The directory's root contains static files, copied from `files` when the site is generated ","isDef":false,"name":["Verso","Genre","Blog","Dir","static"],"signature":"Verso.Genre.Blog.Dir.static (name : String) (files : System.FilePath) : Blog.Dir"}}}}},"name":"Verso.Genre.Blog.Dir.static","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"static","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.203","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"files","kind":{"var":{"name":"_uniq.204","type":"System.FilePath"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"System.FilePath","kind":{"const":{"docs":"A path on the file system.\n\nPaths consist of a sequence of directories followed by the name of a file or directory. They are\ndelimited by a platform-dependent separator character (see `System.FilePath.pathSeparator`).\n","isDef":false,"name":["System","FilePath"],"signature":"System.FilePath : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Dir","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Dir","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":341,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A directory within the layout of a site."}]},{"other":{"container":{"data":"Constructors","id":342,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"page","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.193","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.194","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.196","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.197","type":"Array Blog.Dir"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}}]}},"id":343,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"The directory's root is the provided page"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"blog","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.198","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.199","type":"Lean.Name"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"text","kind":{"var":{"name":"_uniq.201","type":"Part Page"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Part","kind":{"const":{"docs":"A logical division of a document.\n","isDef":false,"name":["Verso","Doc","Part"],"signature":"Verso.Doc.Part (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Page","kind":{"const":{"docs":"An ordinary web page that is not a blog post.\n","isDef":false,"name":["Verso","Genre","Blog","Page"],"signature":"Verso.Genre.Blog.Page : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"contents","kind":{"var":{"name":"_uniq.202","type":"Array Blog.BlogPost"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.BlogPost","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","BlogPost"],"signature":"Verso.Genre.Blog.BlogPost : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}}]}},"id":344,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"The directory's root is a blog"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"static","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.203","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"files","kind":{"var":{"name":"_uniq.204","type":"System.FilePath"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"System.FilePath","kind":{"const":{"docs":"A path on the file system.\n\nPaths consist of a sequence of directories followed by the name of a file or directory. They are\ndelimited by a platform-dependent separator character (see `System.FilePath.pathSeparator`).\n","isDef":false,"name":["System","FilePath"],"signature":"System.FilePath : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Dir","kind":{"const":{"docs":"A directory within the layout of a site.\n","isDef":false,"name":["Verso","Genre","Blog","Dir"],"signature":"Verso.Genre.Blog.Dir : Type"}}}}}]}},"id":345,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"The directory's root contains static files, copied from "},{"other":{"container":{"data":{"token":{"tok":{"content":"files","kind":{"var":{"name":"_uniq.214","type":"System.FilePath"}}}}},"id":346,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"files"}]}},{"text":" when the site is generated"}]}]}}]}}]}}]},{"para":[{"text":"These are usually constructed using a small embedded configuration language."}]},{"para":[{"text":"A blog is rendered using a theme, which is a collection of templates."},{"linebreak":"\n"},{"text":"Templates are monadic functions that construct "},{"other":{"container":{"data":{"token":{"tok":{"content":"Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},"id":347,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Html"}]}},{"text":" from a set of dynamically-typed parameters."}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Theme",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Blog.Theme.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Theme","mk"],"signature":"Verso.Genre.Blog.Theme.mk\n (primaryTemplate pageTemplate postTemplate archiveEntryTemplate categoryTemplate : Blog.Template)\n (adHocTemplates : Array String → Option Blog.Template.Override) (cssFiles : Array (String × String))\n (jsFiles : Array (String × String × Bool)) : Blog.Theme"}}}}},"name":"Verso.Genre.Blog.Theme.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Theme.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"primaryTemplate","kind":{"var":{"name":"_uniq.221","type":"Blog.Template"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"pageTemplate","kind":{"var":{"name":"_uniq.222","type":"Blog.Template"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"postTemplate","kind":{"var":{"name":"_uniq.223","type":"Blog.Template"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"archiveEntryTemplate","kind":{"var":{"name":"_uniq.224","type":"Blog.Template"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"categoryTemplate","kind":{"var":{"name":"_uniq.225","type":"Blog.Template"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"adHocTemplates","kind":{"var":{"name":"_uniq.227","type":"Array String → Option Blog.Template.Override"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Template.Override","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Template","Override"],"signature":"Verso.Genre.Blog.Template.Override : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"cssFiles","kind":{"var":{"name":"_uniq.228","type":"Array (String × String)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"jsFiles","kind":{"var":{"name":"_uniq.229","type":"Array (String × String × Bool)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.Theme","kind":{"const":{"docs":"A specification of how to render a site.\n","isDef":false,"name":["Verso","Genre","Blog","Theme"],"signature":"Verso.Genre.Blog.Theme : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"The template used to render every page. It should construct an HTML value for the entire page,\nincluding the `` element.\n\nIn the `` element, it should invoke `builtinHeader` to ensure that the required dependencies\nare present and that Verso-specific initialization is performed.\n\nIn the body, it should check whether the parameter `\"posts\"` of type `Html` is present. If so, the\npage being rendered is a blog index, so it should place the parameter's value as a list of posts.\nIf `\"categories\"` of type `Post.Categories` is present, it should render the contents as a\ncategory list.\n\nThe parameter `\"content\"` of type `Html` contains the content of the page. It should be placed\naccordingly in the result.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"primaryTemplate","kind":{"const":{"docs":"The template used to render every page. It should construct an HTML value for the entire page,\nincluding the `` element.\n\nIn the `` element, it should invoke `builtinHeader` to ensure that the required dependencies\nare present and that Verso-specific initialization is performed.\n\nIn the body, it should check whether the parameter `\"posts\"` of type `Html` is present. If so, the\npage being rendered is a blog index, so it should place the parameter's value as a list of posts.\nIf `\"categories\"` of type `Post.Categories` is present, it should render the contents as a\ncategory list.\n\nThe parameter `\"content\"` of type `Html` contains the content of the page. It should be placed\naccordingly in the result.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","primaryTemplate"],"signature":"Blog.Template"}}}}},"projFn":"Verso.Genre.Blog.Theme.primaryTemplate","type":{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Pages are rendered using `pageTemplate`, with the result being passed in the `\"content\"` parameter\nto `primaryTemplate`. This template should use the `\"title\"` and `\"content\"` parameters to\nconstruct the contents of the page.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"pageTemplate","kind":{"const":{"docs":"Pages are rendered using `pageTemplate`, with the result being passed in the `\"content\"` parameter\nto `primaryTemplate`. This template should use the `\"title\"` and `\"content\"` parameters to\nconstruct the contents of the page.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","pageTemplate"],"signature":"Blog.Template"}}}}},"projFn":"Verso.Genre.Blog.Theme.pageTemplate","type":{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Blog posts are rendered using `pageTemplate`, with the result being passed in the `\"content\"`\nparameter to `primaryTemplate`. This template should use the `\"title\"` and `\"content\"` parameters\nto construct the contents of the post. Additionally, the `\"metadata\"` template of type\n`\"Post.PartMetadata\"` may be present; if so, it can be used to render the author, date, and\ncategories of the post.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"postTemplate","kind":{"const":{"docs":"Blog posts are rendered using `pageTemplate`, with the result being passed in the `\"content\"`\nparameter to `primaryTemplate`. This template should use the `\"title\"` and `\"content\"` parameters\nto construct the contents of the post. Additionally, the `\"metadata\"` template of type\n`\"Post.PartMetadata\"` may be present; if so, it can be used to render the author, date, and\ncategories of the post.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","postTemplate"],"signature":"Blog.Template"}}}}},"projFn":"Verso.Genre.Blog.Theme.postTemplate","type":{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The template used to summarize a blog post in a post archive. It receives the parameters `\"post\"`,\nwhich contains the post, and `\"summary\"`, which contains the HTML summary to display.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"archiveEntryTemplate","kind":{"const":{"docs":"The template used to summarize a blog post in a post archive. It receives the parameters `\"post\"`,\nwhich contains the post, and `\"summary\"`, which contains the HTML summary to display.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","archiveEntryTemplate"],"signature":"Blog.Template"}}}}},"projFn":"Verso.Genre.Blog.Theme.archiveEntryTemplate","type":{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The template used to display a category at the top of a category's post list. It receives one\nparameter, `\"category\"`, which contains a `Post.Category`.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"categoryTemplate","kind":{"const":{"docs":"The template used to display a category at the top of a category's post list. It receives one\nparameter, `\"category\"`, which contains a `Post.Category`.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","categoryTemplate"],"signature":"Blog.Template"}}}}},"projFn":"Verso.Genre.Blog.Theme.categoryTemplate","type":{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Customize the rendering of a given path by replacing the\ntemplate and providing additional parameters\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"adHocTemplates","kind":{"const":{"docs":"Customize the rendering of a given path by replacing the\ntemplate and providing additional parameters\n","isDef":true,"name":["Verso","Genre","Blog","Theme","adHocTemplates"],"signature":"Array String → Option Blog.Template.Override"}}}}},"projFn":"Verso.Genre.Blog.Theme.adHocTemplates","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Template.Override","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Template","Override"],"signature":"Verso.Genre.Blog.Template.Override : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"CSS files to be referenced in `` and added to generated code.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"cssFiles","kind":{"const":{"docs":"CSS files to be referenced in `` and added to generated code.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","cssFiles"],"signature":"Array (String × String)"}}}}},"projFn":"Verso.Genre.Blog.Theme.cssFiles","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"JS files to be referenced in `` or at the end of `` and added to generated code.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"jsFiles","kind":{"const":{"docs":"JS files to be referenced in `` or at the end of `` and added to generated code.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","jsFiles"],"signature":"Array (String × String × Bool)"}}}}},"projFn":"Verso.Genre.Blog.Theme.jsFiles","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}}]}},"visibility":"public"}],"fieldNames":["primaryTemplate","pageTemplate","postTemplate","archiveEntryTemplate","categoryTemplate","adHocTemplates","cssFiles","jsFiles"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Theme","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Theme","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":348,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A specification of how to render a site."}]},{"other":{"container":{"data":"Constructor","id":349,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Blog.Theme.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Theme","mk"],"signature":"Verso.Genre.Blog.Theme.mk\n (primaryTemplate pageTemplate postTemplate archiveEntryTemplate categoryTemplate : Blog.Template)\n (adHocTemplates : Array String → Option Blog.Template.Override) (cssFiles : Array (String × String))\n (jsFiles : Array (String × String × Bool)) : Blog.Theme"}}}}},null],"id":350,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":351,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"primaryTemplate","kind":{"const":{"docs":"The template used to render every page. It should construct an HTML value for the entire page,\nincluding the `` element.\n\nIn the `` element, it should invoke `builtinHeader` to ensure that the required dependencies\nare present and that Verso-specific initialization is performed.\n\nIn the body, it should check whether the parameter `\"posts\"` of type `Html` is present. If so, the\npage being rendered is a blog index, so it should place the parameter's value as a list of posts.\nIf `\"categories\"` of type `Post.Categories` is present, it should render the contents as a\ncategory list.\n\nThe parameter `\"content\"` of type `Html` contains the content of the page. It should be placed\naccordingly in the result.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","primaryTemplate"],"signature":"Blog.Template"}}}}},[{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},[null,[]]]]],"id":352,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The template used to render every page. It should construct an HTML value for the entire page,"},{"text":"\n"},{"text":"including the "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"html","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":353,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" element."}]},{"para":[{"text":"In the "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"head","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":354,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" element, it should invoke "},{"other":{"container":{"data":{"token":{"tok":{"content":"builtinHeader","kind":"unknown"}}},"id":355,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"builtinHeader"}]}},{"text":" to ensure that the required dependencies"},{"text":"\n"},{"text":"are present and that Verso-specific initialization is performed."}]},{"para":[{"text":"In the body, it should check whether the parameter "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"posts\"","kind":{"str":{"string":"posts"}}}}},"id":356,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"posts\""}]}},{"text":" of type "},{"other":{"container":{"data":{"token":{"tok":{"content":"Html","kind":"unknown"}}},"id":357,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Html"}]}},{"text":" is present. If so, the"},{"text":"\n"},{"text":"page being rendered is a blog index, so it should place the parameter's value as a list of posts."},{"text":"\n"},{"text":"If "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"categories\"","kind":{"str":{"string":"categories"}}}}},"id":358,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"categories\""}]}},{"text":" of type "},{"other":{"container":{"data":{"token":{"tok":{"content":"Post.Categories","kind":{"const":{"docs":"Wrapper around `Array Category` that allows a `TypeName` instance and provides link targets ","isDef":false,"name":["Verso","Genre","Blog","Post","Categories"],"signature":"Verso.Genre.Blog.Post.Categories : Type"}}}}},"id":359,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Post.Categories"}]}},{"text":" is present, it should render the contents as a"},{"text":"\n"},{"text":"category list."}]},{"para":[{"text":"The parameter "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"content\"","kind":{"str":{"string":"content"}}}}},"id":360,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"content\""}]}},{"text":" of type "},{"other":{"container":{"data":{"token":{"tok":{"content":"Html","kind":"unknown"}}},"id":361,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Html"}]}},{"text":" contains the content of the page. It should be placed"},{"text":"\n"},{"text":"accordingly in the result."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"pageTemplate","kind":{"const":{"docs":"Pages are rendered using `pageTemplate`, with the result being passed in the `\"content\"` parameter\nto `primaryTemplate`. This template should use the `\"title\"` and `\"content\"` parameters to\nconstruct the contents of the page.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","pageTemplate"],"signature":"Blog.Template"}}}}},[{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},[null,[]]]]],"id":362,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Pages are rendered using "},{"other":{"container":{"data":{"token":{"tok":{"content":"pageTemplate","kind":{"var":{"name":"_uniq.290","type":"Blog.Template"}}}}},"id":363,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"pageTemplate"}]}},{"text":", with the result being passed in the "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"content\"","kind":{"str":{"string":"content"}}}}},"id":364,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"content\""}]}},{"text":" parameter"},{"text":"\n"},{"text":"to "},{"other":{"container":{"data":{"token":{"tok":{"content":"primaryTemplate","kind":{"var":{"name":"_uniq.289","type":"Blog.Template"}}}}},"id":365,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"primaryTemplate"}]}},{"text":". This template should use the "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"title\"","kind":{"str":{"string":"title"}}}}},"id":366,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"title\""}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"content\"","kind":{"str":{"string":"content"}}}}},"id":367,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"content\""}]}},{"text":" parameters to"},{"text":"\n"},{"text":"construct the contents of the page."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"postTemplate","kind":{"const":{"docs":"Blog posts are rendered using `pageTemplate`, with the result being passed in the `\"content\"`\nparameter to `primaryTemplate`. This template should use the `\"title\"` and `\"content\"` parameters\nto construct the contents of the post. Additionally, the `\"metadata\"` template of type\n`\"Post.PartMetadata\"` may be present; if so, it can be used to render the author, date, and\ncategories of the post.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","postTemplate"],"signature":"Blog.Template"}}}}},[{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},[null,[]]]]],"id":368,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Blog posts are rendered using "},{"other":{"container":{"data":{"token":{"tok":{"content":"pageTemplate","kind":{"var":{"name":"_uniq.302","type":"Blog.Template"}}}}},"id":369,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"pageTemplate"}]}},{"text":", with the result being passed in the "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"content\"","kind":{"str":{"string":"content"}}}}},"id":370,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"content\""}]}},{"text":"\n"},{"text":"parameter to "},{"other":{"container":{"data":{"token":{"tok":{"content":"primaryTemplate","kind":{"var":{"name":"_uniq.301","type":"Blog.Template"}}}}},"id":371,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"primaryTemplate"}]}},{"text":". This template should use the "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"title\"","kind":{"str":{"string":"title"}}}}},"id":372,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"title\""}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"content\"","kind":{"str":{"string":"content"}}}}},"id":373,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"content\""}]}},{"text":" parameters"},{"text":"\n"},{"text":"to construct the contents of the post. Additionally, the "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"metadata\"","kind":{"str":{"string":"metadata"}}}}},"id":374,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"metadata\""}]}},{"text":" template of type"},{"text":"\n"},{"other":{"container":{"data":{"token":{"tok":{"content":"\"Post.PartMetadata\"","kind":{"str":{"string":"Post.PartMetadata"}}}}},"id":375,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"Post.PartMetadata\""}]}},{"text":" may be present; if so, it can be used to render the author, date, and"},{"text":"\n"},{"text":"categories of the post."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"archiveEntryTemplate","kind":{"const":{"docs":"The template used to summarize a blog post in a post archive. It receives the parameters `\"post\"`,\nwhich contains the post, and `\"summary\"`, which contains the HTML summary to display.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","archiveEntryTemplate"],"signature":"Blog.Template"}}}}},[{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},[null,[]]]]],"id":376,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The template used to summarize a blog post in a post archive. It receives the parameters "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"post\"","kind":{"str":{"string":"post"}}}}},"id":377,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"post\""}]}},{"text":","},{"text":"\n"},{"text":"which contains the post, and "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"summary\"","kind":{"str":{"string":"summary"}}}}},"id":378,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"summary\""}]}},{"text":", which contains the HTML summary to display."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"categoryTemplate","kind":{"const":{"docs":"The template used to display a category at the top of a category's post list. It receives one\nparameter, `\"category\"`, which contains a `Post.Category`.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","categoryTemplate"],"signature":"Blog.Template"}}}}},[{"token":{"tok":{"content":"Blog.Template","kind":{"const":{"docs":"A procedure for producing HTML from parameters. An abbreviation for `TemplateM Html`\n","isDef":false,"name":["Verso","Genre","Blog","Template"],"signature":"Verso.Genre.Blog.Template : Type"}}}}},[null,[]]]]],"id":379,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The template used to display a category at the top of a category's post list. It receives one"},{"text":"\n"},{"text":"parameter, "},{"other":{"container":{"data":{"token":{"tok":{"content":"\"category\"","kind":{"str":{"string":"category"}}}}},"id":380,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\"category\""}]}},{"text":", which contains a "},{"other":{"container":{"data":{"token":{"tok":{"content":"Post.Category","kind":{"const":{"docs":"A category of blog posts.\n","isDef":false,"name":["Verso","Genre","Blog","Post","Category"],"signature":"Verso.Genre.Blog.Post.Category : Type"}}}}},"id":381,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Post.Category"}]}},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"adHocTemplates","kind":{"const":{"docs":"Customize the rendering of a given path by replacing the\ntemplate and providing additional parameters\n","isDef":true,"name":["Verso","Genre","Blog","Theme","adHocTemplates"],"signature":"Array String → Option Blog.Template.Override"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.Template.Override","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Blog","Template","Override"],"signature":"Verso.Genre.Blog.Template.Override : Type"}}}}}]}},[null,[]]]]],"id":382,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Customize the rendering of a given path by replacing the"},{"text":"\n"},{"text":"template and providing additional parameters"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"cssFiles","kind":{"const":{"docs":"CSS files to be referenced in `` and added to generated code.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","cssFiles"],"signature":"Array (String × String)"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}}]}},[null,[]]]]],"id":383,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"CSS files to be referenced in "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"head","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":384,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" and added to generated code."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"jsFiles","kind":{"const":{"docs":"JS files to be referenced in `` or at the end of `` and added to generated code.\n","isDef":true,"name":["Verso","Genre","Blog","Theme","jsFiles"],"signature":"Array (String × String × Bool)"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}}]}},[null,[]]]]],"id":385,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"JS files to be referenced in "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"head","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":386,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" or at the end of "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"body","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":387,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" and added to generated code."}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Template",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":388,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A procedure for producing HTML from parameters. An abbreviation for "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"TemplateM","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Html","kind":"unknown"}}}]}},"id":389,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"TemplateM Html"}]}}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.TemplateM",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.TemplateM","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.422","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.TemplateM","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.422","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":390,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A monad that provides template instantiation via dynamically-typed parameters."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Template.param",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template.param","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.429","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"TypeName","kind":{"const":{"docs":"Dynamic type name information.\nTypes with an instance of `TypeName` can be stored in an `Dynamic`.\nThe type class contains the declaration name of the type,\nwhich must not have any universe parameters\nand be of type `Sort ..` (i.e., monomorphic).\n\nThe preferred way to declare instances of this type is using the derive\nhandler, which will internally use the unsafe `TypeName.mk` function.\n\nMorally, this is the same as:\n```lean\nclass TypeName (α : Type) where unsafe mk ::\n typeName : Name\n```\n","isDef":false,"name":["TypeName"],"signature":"TypeName.{u} (α : Type u) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.429","type":"Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"key","kind":{"var":{"name":"_uniq.431","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.TemplateM","kind":{"const":{"docs":"A monad that provides template instantiation via dynamically-typed parameters.\n","isDef":false,"name":["Verso","Genre","Blog","TemplateM"],"signature":"Verso.Genre.Blog.TemplateM (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.429","type":"Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template.param","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.429","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"TypeName","kind":{"const":{"docs":"Dynamic type name information.\nTypes with an instance of `TypeName` can be stored in an `Dynamic`.\nThe type class contains the declaration name of the type,\nwhich must not have any universe parameters\nand be of type `Sort ..` (i.e., monomorphic).\n\nThe preferred way to declare instances of this type is using the derive\nhandler, which will internally use the unsafe `TypeName.mk` function.\n\nMorally, this is the same as:\n```lean\nclass TypeName (α : Type) where unsafe mk ::\n typeName : Name\n```\n","isDef":false,"name":["TypeName"],"signature":"TypeName.{u} (α : Type u) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.429","type":"Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"key","kind":{"var":{"name":"_uniq.431","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.TemplateM","kind":{"const":{"docs":"A monad that provides template instantiation via dynamically-typed parameters.\n","isDef":false,"name":["Verso","Genre","Blog","TemplateM"],"signature":"Verso.Genre.Blog.TemplateM (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.429","type":"Type"}}}}}]}}},[null,[]]]]],"id":391,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Returns the value of the given template, if it exists. If it does not exist or if it exists but has"},{"text":"\n"},{"text":"the wrong type, an exception is thrown."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Template.param?",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template.param?","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.439","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"TypeName","kind":{"const":{"docs":"Dynamic type name information.\nTypes with an instance of `TypeName` can be stored in an `Dynamic`.\nThe type class contains the declaration name of the type,\nwhich must not have any universe parameters\nand be of type `Sort ..` (i.e., monomorphic).\n\nThe preferred way to declare instances of this type is using the derive\nhandler, which will internally use the unsafe `TypeName.mk` function.\n\nMorally, this is the same as:\n```lean\nclass TypeName (α : Type) where unsafe mk ::\n typeName : Name\n```\n","isDef":false,"name":["TypeName"],"signature":"TypeName.{u} (α : Type u) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.439","type":"Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"key","kind":{"var":{"name":"_uniq.441","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.TemplateM","kind":{"const":{"docs":"A monad that provides template instantiation via dynamically-typed parameters.\n","isDef":false,"name":["Verso","Genre","Blog","TemplateM"],"signature":"Verso.Genre.Blog.TemplateM (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.439","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template.param?","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"{","kind":"unknown"}}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.439","type":"Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}},{"token":{"tok":{"content":"}","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"[","kind":"unknown"}}},{"token":{"tok":{"content":"TypeName","kind":{"const":{"docs":"Dynamic type name information.\nTypes with an instance of `TypeName` can be stored in an `Dynamic`.\nThe type class contains the declaration name of the type,\nwhich must not have any universe parameters\nand be of type `Sort ..` (i.e., monomorphic).\n\nThe preferred way to declare instances of this type is using the derive\nhandler, which will internally use the unsafe `TypeName.mk` function.\n\nMorally, this is the same as:\n```lean\nclass TypeName (α : Type) where unsafe mk ::\n typeName : Name\n```\n","isDef":false,"name":["TypeName"],"signature":"TypeName.{u} (α : Type u) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.439","type":"Type"}}}}},{"token":{"tok":{"content":"]","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"key","kind":{"var":{"name":"_uniq.441","type":"String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.TemplateM","kind":{"const":{"docs":"A monad that provides template instantiation via dynamically-typed parameters.\n","isDef":false,"name":["Verso","Genre","Blog","TemplateM"],"signature":"Verso.Genre.Blog.TemplateM (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"α","kind":{"var":{"name":"_uniq.439","type":"Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}}},[null,[]]]]],"id":392,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Returns the value of the given template, if it exists."},{"text":"\n"},{"text":"If it exists but has the wrong type, an exception is thrown."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Blog.Template.builtinHeader",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template.builtinHeader","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Blog.TemplateM","kind":{"const":{"docs":"A monad that provides template instantiation via dynamically-typed parameters.\n","isDef":false,"name":["Verso","Genre","Blog","TemplateM"],"signature":"Verso.Genre.Blog.TemplateM (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Blog.Template.builtinHeader","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Blog.TemplateM","kind":{"const":{"docs":"A monad that provides template instantiation via dynamically-typed parameters.\n","isDef":false,"name":["Verso","Genre","Blog","TemplateM"],"signature":"Verso.Genre.Blog.TemplateM (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}}]}}},[null,[]]]]],"id":393,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Contains the contents of "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"<","kind":"unknown"}}},{"token":{"tok":{"content":"head","kind":"unknown"}}},{"token":{"tok":{"content":">","kind":"unknown"}}}]}},"id":394,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":""}]}},{"text":" that are needed for proper functioning of the site."}]}]}}]}],"metadata":{"assignedNumber":2,"authors":[],"authorshipNote":null,"date":null,"draft":false,"file":null,"htmlSplit":"default","htmlToc":true,"id":335,"number":true,"shortContextTitle":null,"shortTitle":null,"tag":{"external":{"name":"site-config"}}},"subParts":[],"title":[{"text":"Configuring a Site"}],"titleString":"Configuring a Site"}],"title":[{"text":"Websites"}],"titleString":"Websites"},{"content":[{"para":[{"text":"Verso's "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},"id":396,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual"}]}},{"text":" genre can be used to write reference manuals, textbooks, or other book-like documents."},{"linebreak":"\n"},{"text":"It supports generating both HTML and PDFs via LaTeX, but the PDF support is relatively immature and untested compared to the HTML support."}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual",[{"def":{"safety":"safe"}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Genre","kind":{"const":{"docs":"A genre is a kind of document that can be written with Verso\\.\n\nA genre is primarily defined by its extensions to the Verso framework, provided in this type\\.\nAdditionally, each genre should provide a `main` function that is responsible for the traversal pass\nand for generating output\\.\n","isDef":false,"name":["Verso","Doc","Genre"],"signature":"Verso.Doc.Genre : Type 1"}}}}}]}}},[null,[]]]]],"id":397,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A genre for writing reference manuals and other book-like documents."}]}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.PartMetadata",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.PartMetadata.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","PartMetadata","mk"],"signature":"Verso.Genre.Manual.PartMetadata.mk (shortTitle shortContextTitle : Option String) (authors : List String)\n (authorshipNote date : Option String) (tag : Option Tag) (file : Option String) (id : Option InternalId)\n (number draft : Bool) (assignedNumber : Option Numbering) (htmlToc : Bool) (htmlSplit : HtmlSplitMode) : PartMetadata"}}}}},"name":"Verso.Genre.Manual.PartMetadata.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.PartMetadata.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"shortTitle","kind":{"var":{"name":"_uniq.10","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"shortContextTitle","kind":{"var":{"name":"_uniq.11","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"authors","kind":{"var":{"name":"_uniq.12","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"authorshipNote","kind":{"var":{"name":"_uniq.13","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"date","kind":{"var":{"name":"_uniq.14","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"tag","kind":{"var":{"name":"_uniq.15","type":"Option Tag"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Tag","kind":{"const":{"docs":"Tags are used to refer to parts through tables of contents, cross-references, and the like.\n\nDuring the traverse pass, the following steps occur:\n 1. user-provided tags are ensured to be globally unique, and saved as xref targets\n 2. internal tags are heuristically assigned to parts based on their section names\n 3. internal tags are converted to unique external tags, but not provided for user-written xrefs\n (needed for automatic linking, e.g. in a table of contents)\n\nNote that internal invariants about uniqueness of names can be violated by editing the JSON\nserialization. This may lead to unexpected results.\n","isDef":false,"name":["Verso","Genre","Manual","Tag"],"signature":"Verso.Genre.Manual.Tag : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"file","kind":{"var":{"name":"_uniq.16","type":"Option String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.17","type":"Option InternalId"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"number","kind":{"var":{"name":"_uniq.18","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"draft","kind":{"var":{"name":"_uniq.19","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"assignedNumber","kind":{"var":{"name":"_uniq.20","type":"Option Numbering"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Numbering","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Numbering"],"signature":"Verso.Genre.Manual.Numbering : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmlToc","kind":{"var":{"name":"_uniq.21","type":"Bool"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"htmlSplit","kind":{"var":{"name":"_uniq.22","type":"HtmlSplitMode"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"PartMetadata","kind":{"const":{"docs":"Metadata for the manual ","isDef":false,"name":["Verso","Genre","Manual","PartMetadata"],"signature":"Verso.Genre.Manual.PartMetadata : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"A shorter title to be shown in titlebars and tables of contents.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"shortTitle","kind":{"const":{"docs":"A shorter title to be shown in titlebars and tables of contents.\n","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","shortTitle"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.shortTitle","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"A shorter title to be shown in breadcrumbs for search results. Should typically be at least as\nshort as `shortTitle`.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"shortContextTitle","kind":{"const":{"docs":"A shorter title to be shown in breadcrumbs for search results. Should typically be at least as\nshort as `shortTitle`.\n","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","shortContextTitle"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.shortContextTitle","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The book's authors ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"authors","kind":{"const":{"docs":"The book's authors ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","authors"],"signature":"List String"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.authors","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"An extra note to show after the author list ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"authorshipNote","kind":{"const":{"docs":"An extra note to show after the author list ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","authorshipNote"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.authorshipNote","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The publication date ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"date","kind":{"const":{"docs":"The publication date ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","date"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.date","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The main tag for the part, used for cross-references. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"tag","kind":{"const":{"docs":"The main tag for the part, used for cross-references. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","tag"],"signature":"Option Tag"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.tag","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Tag","kind":{"const":{"docs":"Tags are used to refer to parts through tables of contents, cross-references, and the like.\n\nDuring the traverse pass, the following steps occur:\n 1. user-provided tags are ensured to be globally unique, and saved as xref targets\n 2. internal tags are heuristically assigned to parts based on their section names\n 3. internal tags are converted to unique external tags, but not provided for user-written xrefs\n (needed for automatic linking, e.g. in a table of contents)\n\nNote that internal invariants about uniqueness of names can be violated by editing the JSON\nserialization. This may lead to unexpected results.\n","isDef":false,"name":["Verso","Genre","Manual","Tag"],"signature":"Verso.Genre.Manual.Tag : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"If this part ends up as the root of a file, use this name for it ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"file","kind":{"const":{"docs":"If this part ends up as the root of a file, use this name for it ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","file"],"signature":"Option String"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.file","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The internal unique ID, which is automatically assigned during traversal. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"id","kind":{"const":{"docs":"The internal unique ID, which is automatically assigned during traversal. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","id"],"signature":"Option InternalId"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.id","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Should this section be numbered? If `false`, then it's like `\\section*` in LaTeX ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"number","kind":{"const":{"docs":"Should this section be numbered? If `false`, then it's like `\\section*` in LaTeX ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","number"],"signature":"Bool"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.number","type":{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"If `true`, the part is only rendered in draft mode. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"draft","kind":{"const":{"docs":"If `true`, the part is only rendered in draft mode. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","draft"],"signature":"Bool"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.draft","type":{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Which number has been assigned? This field is set during traversal. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"assignedNumber","kind":{"const":{"docs":"Which number has been assigned? This field is set during traversal. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","assignedNumber"],"signature":"Option Numbering"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.assignedNumber","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Numbering","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Numbering"],"signature":"Verso.Genre.Manual.Numbering : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"If `true`, this part will display a list of subparts that are separate HTML pages. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"htmlToc","kind":{"const":{"docs":"If `true`, this part will display a list of subparts that are separate HTML pages. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","htmlToc"],"signature":"Bool"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.htmlToc","type":{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How should this document be split when rendering multi-page HTML output? ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"htmlSplit","kind":{"const":{"docs":"How should this document be split when rendering multi-page HTML output? ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","htmlSplit"],"signature":"HtmlSplitMode"}}}}},"projFn":"Verso.Genre.Manual.PartMetadata.htmlSplit","type":{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}},"visibility":"public"}],"fieldNames":["shortTitle","shortContextTitle","authors","authorshipNote","date","tag","file","id","number","draft","assignedNumber","htmlToc","htmlSplit"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.PartMetadata","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.PartMetadata","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":398,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Metadata for the manual"}]},{"other":{"container":{"data":"Constructor","id":399,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Manual.PartMetadata.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","PartMetadata","mk"],"signature":"Verso.Genre.Manual.PartMetadata.mk (shortTitle shortContextTitle : Option String) (authors : List String)\n (authorshipNote date : Option String) (tag : Option Tag) (file : Option String) (id : Option InternalId)\n (number draft : Bool) (assignedNumber : Option Numbering) (htmlToc : Bool) (htmlSplit : HtmlSplitMode) : PartMetadata"}}}}},null],"id":400,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":401,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"shortTitle","kind":{"const":{"docs":"A shorter title to be shown in titlebars and tables of contents.\n","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","shortTitle"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":402,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A shorter title to be shown in titlebars and tables of contents."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"shortContextTitle","kind":{"const":{"docs":"A shorter title to be shown in breadcrumbs for search results. Should typically be at least as\nshort as `shortTitle`.\n","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","shortContextTitle"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":403,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A shorter title to be shown in breadcrumbs for search results. Should typically be at least as"},{"text":"\n"},{"text":"short as "},{"other":{"container":{"data":{"token":{"tok":{"content":"shortTitle","kind":{"var":{"name":"_uniq.36","type":"Option String"}}}}},"id":404,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"shortTitle"}]}},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"authors","kind":{"const":{"docs":"The book's authors ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","authors"],"signature":"List String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":405,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The book's authors"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"authorshipNote","kind":{"const":{"docs":"An extra note to show after the author list ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","authorshipNote"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":406,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"An extra note to show after the author list"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"date","kind":{"const":{"docs":"The publication date ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","date"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":407,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The publication date"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"tag","kind":{"const":{"docs":"The main tag for the part, used for cross-references. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","tag"],"signature":"Option Tag"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Tag","kind":{"const":{"docs":"Tags are used to refer to parts through tables of contents, cross-references, and the like.\n\nDuring the traverse pass, the following steps occur:\n 1. user-provided tags are ensured to be globally unique, and saved as xref targets\n 2. internal tags are heuristically assigned to parts based on their section names\n 3. internal tags are converted to unique external tags, but not provided for user-written xrefs\n (needed for automatic linking, e.g. in a table of contents)\n\nNote that internal invariants about uniqueness of names can be violated by editing the JSON\nserialization. This may lead to unexpected results.\n","isDef":false,"name":["Verso","Genre","Manual","Tag"],"signature":"Verso.Genre.Manual.Tag : Type"}}}}}]}},[null,[]]]]],"id":408,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The main tag for the part, used for cross-references."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"file","kind":{"const":{"docs":"If this part ends up as the root of a file, use this name for it ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","file"],"signature":"Option String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":409,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"If this part ends up as the root of a file, use this name for it"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"id","kind":{"const":{"docs":"The internal unique ID, which is automatically assigned during traversal. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","id"],"signature":"Option InternalId"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}}]}},[null,[]]]]],"id":410,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The internal unique ID, which is automatically assigned during traversal."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"number","kind":{"const":{"docs":"Should this section be numbered? If `false`, then it's like `\\section*` in LaTeX ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","number"],"signature":"Bool"}}}}},[{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},[null,[]]]]],"id":411,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Should this section be numbered? If "},{"other":{"container":{"data":{"token":{"tok":{"content":"false","kind":{"const":{"docs":"The Boolean value `false`, not to be confused with the proposition `False`. ","isDef":false,"name":["Bool","false"],"signature":"Bool.false : Bool"}}}}},"id":412,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"false"}]}},{"text":", then it's like "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"\\","kind":"unknown"}}},{"token":{"tok":{"content":"section","kind":{"keyword":{"docs":null,"name":["null"],"occurrence":"null-0"}}}}},{"token":{"tok":{"content":"*","kind":"unknown"}}}]}},"id":413,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\\section*"}]}},{"text":" in LaTeX"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"draft","kind":{"const":{"docs":"If `true`, the part is only rendered in draft mode. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","draft"],"signature":"Bool"}}}}},[{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},[null,[]]]]],"id":414,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"If "},{"other":{"container":{"data":{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},"id":415,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"true"}]}},{"text":", the part is only rendered in draft mode."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"assignedNumber","kind":{"const":{"docs":"Which number has been assigned? This field is set during traversal. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","assignedNumber"],"signature":"Option Numbering"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Numbering","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Numbering"],"signature":"Verso.Genre.Manual.Numbering : Type"}}}}}]}},[null,[]]]]],"id":416,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Which number has been assigned? This field is set during traversal."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"htmlToc","kind":{"const":{"docs":"If `true`, this part will display a list of subparts that are separate HTML pages. ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","htmlToc"],"signature":"Bool"}}}}},[{"token":{"tok":{"content":"Bool","kind":{"const":{"docs":"The Boolean values, `true` and `false`.\n\nLogically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is\npublic important for programming: both propositions and their proofs are erased in the code generator,\nwhile `Bool` corresponds to the Boolean type in most programming languages and carries precisely one\nbit of run-time information.\n","isDef":false,"name":["Bool"],"signature":"Bool : Type"}}}}},[null,[]]]]],"id":417,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"If "},{"other":{"container":{"data":{"token":{"tok":{"content":"true","kind":{"const":{"docs":"The Boolean value `true`, not to be confused with the proposition `True`. ","isDef":false,"name":["Bool","true"],"signature":"Bool.true : Bool"}}}}},"id":418,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"true"}]}},{"text":", this part will display a list of subparts that are separate HTML pages."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"htmlSplit","kind":{"const":{"docs":"How should this document be split when rendering multi-page HTML output? ","isDef":true,"name":["Verso","Genre","Manual","PartMetadata","htmlSplit"],"signature":"HtmlSplitMode"}}}}},[{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}},[null,[]]]]],"id":419,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How should this document be split when rendering multi-page HTML output?"}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.HtmlSplitMode",[{"inductive":{"constructors":[{"docstring":"Follow the main setting ","hlName":{"token":{"tok":{"content":"default","kind":{"const":{"docs":"Follow the main setting ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode","default"],"signature":"Verso.Genre.Manual.HtmlSplitMode.default : HtmlSplitMode"}}}}},"name":"Verso.Genre.Manual.HtmlSplitMode.default","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"default","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}}]}}},{"docstring":"Do not split here nor in child parts ","hlName":{"token":{"tok":{"content":"never","kind":{"const":{"docs":"Do not split here nor in child parts ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode","never"],"signature":"Verso.Genre.Manual.HtmlSplitMode.never : HtmlSplitMode"}}}}},"name":"Verso.Genre.Manual.HtmlSplitMode.never","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"never","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}}]}}}],"numArgs":0,"propOnly":false}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlSplitMode","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlSplitMode","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":420,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"When rendering multi-page HTML, should splitting pages follow the depth setting?"}]},{"other":{"container":{"data":"Constructors","id":421,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"default","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}}]}},"id":422,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Follow the main setting"}]}]}},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"never","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlSplitMode","kind":{"const":{"docs":"When rendering multi-page HTML, should splitting pages follow the depth setting? ","isDef":false,"name":["Verso","Genre","Manual","HtmlSplitMode"],"signature":"Verso.Genre.Manual.HtmlSplitMode : Type"}}}}}]}},"id":423,"name":"Verso.Genre.Manual.Block.constructorSignature","properties":{}},"content":[{"para":[{"text":"Do not split here nor in child parts"}]}]}}]}}]}}]},{"para":[{"text":"The "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},"id":424,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual"}]}},{"text":" genre's block and inline element types are extensible."},{"linebreak":"\n"},{"text":"In the document, they consist of instances of "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual.Block","kind":{"const":{"docs":"A custom block. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Block"],"signature":"Verso.Genre.Manual.Block : Type"}}}}},"id":425,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual.Block"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual.Inline","kind":{"const":{"docs":"A custom inline. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Inline"],"signature":"Verso.Genre.Manual.Inline : Type"}}}}},"id":426,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual.Inline"}]}},{"text":", respectively:"}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.Block",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.Block.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Block","mk"],"signature":"Verso.Genre.Manual.Block.mk (name : Lean.Name := by exact decl_name%) (id : Option InternalId) (data : Lean.Json)\n (properties : NameMap String) : Manual.Block"}}}}},"name":"Verso.Genre.Manual.Block.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.Block.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.199","type":"autoParam Lean.Name Block.name._autoParam"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"by","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"exact","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"decl_name%)","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.200","type":"Option InternalId"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"data","kind":{"var":{"name":"_uniq.201","type":"Lean.Json"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"properties","kind":{"var":{"name":"_uniq.203","type":"NameMap String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"NameMap","kind":{"const":{"docs":"A Verso `NameMap` maps non\\-empty, string\\-only names to some kind of value\\.\n","isDef":false,"name":["Verso","NameMap"],"signature":"Verso.NameMap (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Manual.Block","kind":{"const":{"docs":"A custom block. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Block"],"signature":"Verso.Genre.Manual.Block : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"A unique name that identifies the block. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"name","kind":{"const":{"docs":"A unique name that identifies the block. ","isDef":true,"name":["Verso","Genre","Manual","Block","name"],"signature":"Lean.Name"}}}}},"projFn":"Verso.Genre.Manual.Block.name","type":{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"A unique ID, assigned during traversal. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"id","kind":{"const":{"docs":"A unique ID, assigned during traversal. ","isDef":true,"name":["Verso","Genre","Manual","Block","id"],"signature":"Option InternalId"}}}}},"projFn":"Verso.Genre.Manual.Block.id","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Data saved by elaboration, potentially updated during traversal, and used to render output. This\nis the primary means of communicating information about a block between phases.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"data","kind":{"const":{"docs":"Data saved by elaboration, potentially updated during traversal, and used to render output. This\nis the primary means of communicating information about a block between phases.\n","isDef":true,"name":["Verso","Genre","Manual","Block","data"],"signature":"Lean.Json"}}}}},"projFn":"Verso.Genre.Manual.Block.data","type":{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"A registry for properties that can be used to create ad-hoc protocols for coordination between\nblock elements in extensions.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"properties","kind":{"const":{"docs":"A registry for properties that can be used to create ad-hoc protocols for coordination between\nblock elements in extensions.\n","isDef":true,"name":["Verso","Genre","Manual","Block","properties"],"signature":"NameMap String"}}}}},"projFn":"Verso.Genre.Manual.Block.properties","type":{"seq":{"highlights":[{"token":{"tok":{"content":"NameMap","kind":{"const":{"docs":"A Verso `NameMap` maps non\\-empty, string\\-only names to some kind of value\\.\n","isDef":false,"name":["Verso","NameMap"],"signature":"Verso.NameMap (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["name","id","data","properties"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.Block","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.Block","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":427,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A custom block. The "},{"other":{"container":{"data":{"token":{"tok":{"content":"name","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineLean","name"],"signature":"Verso.Genre.Manual.InlineLean.name : Elab.RoleExpanderOf NameConfig"}}}}},"id":428,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"name"}]}},{"text":" field should correspond to an entry in the block descriptions table."}]},{"other":{"container":{"data":"Constructor","id":429,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Manual.Block.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Block","mk"],"signature":"Verso.Genre.Manual.Block.mk (name : Lean.Name := by exact decl_name%) (id : Option InternalId) (data : Lean.Json)\n (properties : NameMap String) : Manual.Block"}}}}},null],"id":430,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":431,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"name","kind":{"const":{"docs":"A unique name that identifies the block. ","isDef":true,"name":["Verso","Genre","Manual","Block","name"],"signature":"Lean.Name"}}}}},[{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},[null,[]]]]],"id":432,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A unique name that identifies the block."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"id","kind":{"const":{"docs":"A unique ID, assigned during traversal. ","isDef":true,"name":["Verso","Genre","Manual","Block","id"],"signature":"Option InternalId"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}}]}},[null,[]]]]],"id":433,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A unique ID, assigned during traversal."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"data","kind":{"const":{"docs":"Data saved by elaboration, potentially updated during traversal, and used to render output. This\nis the primary means of communicating information about a block between phases.\n","isDef":true,"name":["Verso","Genre","Manual","Block","data"],"signature":"Lean.Json"}}}}},[{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},[null,[]]]]],"id":434,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Data saved by elaboration, potentially updated during traversal, and used to render output. This"},{"text":"\n"},{"text":"is the primary means of communicating information about a block between phases."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"properties","kind":{"const":{"docs":"A registry for properties that can be used to create ad-hoc protocols for coordination between\nblock elements in extensions.\n","isDef":true,"name":["Verso","Genre","Manual","Block","properties"],"signature":"NameMap String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"NameMap","kind":{"const":{"docs":"A Verso `NameMap` maps non\\-empty, string\\-only names to some kind of value\\.\n","isDef":false,"name":["Verso","NameMap"],"signature":"Verso.NameMap (α : Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[]]]]],"id":435,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A registry for properties that can be used to create ad-hoc protocols for coordination between"},{"text":"\n"},{"text":"block elements in extensions."}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.Inline",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.Inline.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Inline","mk"],"signature":"Verso.Genre.Manual.Inline.mk (name : Lean.Name := by exact decl_name%) (id : Option InternalId) (data : Lean.Json) :\n Manual.Inline"}}}}},"name":"Verso.Genre.Manual.Inline.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.Inline.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"name","kind":{"var":{"name":"_uniq.224","type":"autoParam Lean.Name Inline.name._autoParam"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":=","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"by","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"exact","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"decl_name%)","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"id","kind":{"var":{"name":"_uniq.225","type":"Option InternalId"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"data","kind":{"var":{"name":"_uniq.226","type":"Lean.Json"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual.Inline","kind":{"const":{"docs":"A custom inline. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Inline"],"signature":"Verso.Genre.Manual.Inline : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"A unique name that identifies the inline. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"name","kind":{"const":{"docs":"A unique name that identifies the inline. ","isDef":true,"name":["Verso","Genre","Manual","Inline","name"],"signature":"Lean.Name"}}}}},"projFn":"Verso.Genre.Manual.Inline.name","type":{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"The internal unique ID, which is automatically assigned during traversal. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"id","kind":{"const":{"docs":"The internal unique ID, which is automatically assigned during traversal. ","isDef":true,"name":["Verso","Genre","Manual","Inline","id"],"signature":"Option InternalId"}}}}},"projFn":"Verso.Genre.Manual.Inline.id","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Data saved by elaboration, potentially updated during traversal, and used to render output. This\nis the primary means of communicating information about a block between phases.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"data","kind":{"const":{"docs":"Data saved by elaboration, potentially updated during traversal, and used to render output. This\nis the primary means of communicating information about a block between phases.\n","isDef":true,"name":["Verso","Genre","Manual","Inline","data"],"signature":"Lean.Json"}}}}},"projFn":"Verso.Genre.Manual.Inline.data","type":{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},"visibility":"public"}],"fieldNames":["name","id","data"],"isClass":false,"parents":[]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.Inline","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.Inline","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":436,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"A custom inline. The "},{"other":{"container":{"data":{"token":{"tok":{"content":"name","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineLean","name"],"signature":"Verso.Genre.Manual.InlineLean.name : Elab.RoleExpanderOf NameConfig"}}}}},"id":437,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"name"}]}},{"text":" field should correspond to an entry in the block descriptions table."}]},{"other":{"container":{"data":"Constructor","id":438,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Manual.Inline.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","Inline","mk"],"signature":"Verso.Genre.Manual.Inline.mk (name : Lean.Name := by exact decl_name%) (id : Option InternalId) (data : Lean.Json) :\n Manual.Inline"}}}}},null],"id":439,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":440,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"name","kind":{"const":{"docs":"A unique name that identifies the inline. ","isDef":true,"name":["Verso","Genre","Manual","Inline","name"],"signature":"Lean.Name"}}}}},[{"token":{"tok":{"content":"Lean.Name","kind":{"const":{"docs":"Hierarchical names consist of a sequence of components, each of\nwhich is either a string or numeric, that are written separated by dots (`.`).\n\nHierarchical names are used to name declarations and for creating\nunique identifiers for free variables and metavariables.\n\nYou can create hierarchical names using a backtick:\n```\n`Lean.Meta.whnf\n```\nIt is short for `.str (.str (.str .anonymous \"Lean\") \"Meta\") \"whnf\"`.\n\nYou can use double backticks to request Lean to statically check whether the name\ncorresponds to a Lean declaration in scope.\n```\n``Lean.Meta.whnf\n```\nIf the name is not in scope, Lean will report an error.\n\nThere are two ways to convert a `String` to a `Name`:\n\n 1. `Name.mkSimple` creates a name with a single string component.\n\n 2. `String.toName` first splits the string into its dot-separated\n components, and then creates a hierarchical name.\n","isDef":false,"name":["Lean","Name"],"signature":"Lean.Name : Type"}}}}},[null,[]]]]],"id":441,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"A unique name that identifies the inline."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"id","kind":{"const":{"docs":"The internal unique ID, which is automatically assigned during traversal. ","isDef":true,"name":["Verso","Genre","Manual","Inline","id"],"signature":"Option InternalId"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}}]}},[null,[]]]]],"id":442,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"The internal unique ID, which is automatically assigned during traversal."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"data","kind":{"const":{"docs":"Data saved by elaboration, potentially updated during traversal, and used to render output. This\nis the primary means of communicating information about a block between phases.\n","isDef":true,"name":["Verso","Genre","Manual","Inline","data"],"signature":"Lean.Json"}}}}},[{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},[null,[]]]]],"id":443,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Data saved by elaboration, potentially updated during traversal, and used to render output. This"},{"text":"\n"},{"text":"is the primary means of communicating information about a block between phases."}]}]}}]}}]}}]},{"para":[{"text":"The fields "},{"other":{"container":{"data":{"token":{"tok":{"content":"Block.name","kind":{"const":{"docs":"A unique name that identifies the block. ","isDef":false,"name":["Verso","Genre","Manual","Block","name"],"signature":"Verso.Genre.Manual.Block.name (self : Manual.Block) : Lean.Name"}}}}},"id":444,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Block.name"}]}},{"text":" and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Inline.name","kind":{"const":{"docs":"A unique name that identifies the inline. ","isDef":false,"name":["Verso","Genre","Manual","Inline","name"],"signature":"Verso.Genre.Manual.Inline.name (self : Manual.Inline) : Lean.Name"}}}}},"id":445,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Inline.name"}]}},{"text":" are used to look up concrete implementations of traversal and output generation in run-time tables that contain descriptions:"}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.BlockDescr",[{"structure":{"ancestors":["Verso.Genre.Manual.HtmlAssets"],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.BlockDescr.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockDescr","mk"],"signature":"Verso.Genre.Manual.BlockDescr.mk (toHtmlAssets : HtmlAssets) (init : TraverseState → TraverseState)\n (traverse : BlockTraversal Manual)\n (toHtml : Option (BlockToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO))))\n (localContentItem : InternalId → Lean.Json → Array (Doc.Block Manual) → Except String (Array (String × Output.Html)))\n (toTeX : Option (BlockToTeX Manual (ReaderT ExtensionImpls IO))) (usePackages preamble : List String) : BlockDescr"}}}}},"name":"Verso.Genre.Manual.BlockDescr.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.BlockDescr.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"toHtmlAssets","kind":{"var":{"name":"_uniq.277","type":"HtmlAssets"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"init","kind":{"var":{"name":"_uniq.279","type":"TraverseState → TraverseState"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"traverse","kind":{"var":{"name":"_uniq.281","type":"BlockTraversal Manual"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"BlockTraversal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockTraversal"],"signature":"Verso.Genre.Manual.BlockTraversal (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"toHtml","kind":{"var":{"name":"_uniq.290","type":"Option (BlockToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO)))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"BlockToHtml","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockToHtml"],"signature":"Verso.Genre.Manual.BlockToHtml (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Multi.AllRemotes","kind":{"const":{"docs":"All remote data that was loaded\\.\n","isDef":false,"name":["Verso","Multi","AllRemotes"],"signature":"Verso.Multi.AllRemotes : Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"localContentItem","kind":{"var":{"name":"_uniq.297","type":"InternalId → Lean.Json → Array (Doc.Block Manual) → Except String (Array (String × Output.Html))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Except","kind":{"const":{"docs":"`Except ε α` is a type which represents either an error of type `ε` or a successful result with a\nvalue of type `α`.\n\n`Except ε : Type u → Type v` is a `Monad` that represents computations that may throw exceptions:\nthe `pure` operation is `Except.ok` and the `bind` operation returns the first encountered\n`Except.error`.\n","isDef":false,"name":["Except"],"signature":"Except.{u, v} (ε : Type u) (α : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"toTeX","kind":{"var":{"name":"_uniq.302","type":"Option (BlockToTeX Manual (ReaderT ExtensionImpls IO))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"BlockToTeX","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockToTeX"],"signature":"Verso.Genre.Manual.BlockToTeX (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"usePackages","kind":{"var":{"name":"_uniq.303","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"preamble","kind":{"var":{"name":"_uniq.304","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"BlockDescr","kind":{"const":{"docs":"Implementations of all the operations needed to use a block.\n","isDef":false,"name":["Verso","Genre","Manual","BlockDescr"],"signature":"Verso.Genre.Manual.BlockDescr : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"toHtmlAssets","kind":{"const":{"docs":null,"isDef":true,"name":["Verso","Genre","Manual","BlockDescr","toHtmlAssets"],"signature":"HtmlAssets"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.toHtmlAssets","subobject":"Verso.Genre.Manual.HtmlAssets","type":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraCss","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CSS","kind":{"const":{"docs":"Cascading Stylesheet code\\.\n","isDef":false,"name":["Verso","Genre","Manual","CSS"],"signature":"Verso.Genre.Manual.CSS : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraJs","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JS","kind":{"const":{"docs":"JavaScript code\\.\n","isDef":false,"name":["Verso","Genre","Manual","JS"],"signature":"Verso.Genre.Manual.JS : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraJsFiles","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JsFile","kind":{"const":{"docs":"An extra JS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","JsFile"],"signature":"Verso.Genre.Manual.JsFile : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraCssFiles","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CssFile","kind":{"const":{"docs":"An extra CSS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","CssFile"],"signature":"Verso.Genre.Manual.CssFile : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraDataFiles","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"DataFile","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","DataFile"],"signature":"Verso.Genre.Manual.DataFile : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"licenseInfo","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"LicenseInfo","kind":{"const":{"docs":"A description of an open-source license used by a frontend component that's included in\ngenerated HTML. This is used to create an attribution page.\n","isDef":false,"name":["Verso","Genre","Manual","LicenseInfo"],"signature":"Verso.Genre.Manual.LicenseInfo : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"All registered initializers are called in the state prior to the first traversal. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"init","kind":{"const":{"docs":"All registered initializers are called in the state prior to the first traversal. ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","init"],"signature":"TraverseState → TraverseState"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.init","type":{"seq":{"highlights":[{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How the traversal phase should process this block ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"traverse","kind":{"const":{"docs":"How the traversal phase should process this block ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","traverse"],"signature":"BlockTraversal Manual"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.traverse","type":{"seq":{"highlights":[{"token":{"tok":{"content":"BlockTraversal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockTraversal"],"signature":"Verso.Genre.Manual.BlockTraversal (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How to generate HTML. If `none`, generating HTML from a document that contains this block will fail.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"toHtml","kind":{"const":{"docs":"How to generate HTML. If `none`, generating HTML from a document that contains this block will fail.\n","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","toHtml"],"signature":"Option (BlockToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO)))"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.toHtml","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"BlockToHtml","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockToHtml"],"signature":"Verso.Genre.Manual.BlockToHtml (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Multi.AllRemotes","kind":{"const":{"docs":"All remote data that was loaded\\.\n","isDef":false,"name":["Verso","Multi","AllRemotes"],"signature":"Verso.Multi.AllRemotes : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Should this block be an entry in the page-local ToC? If so, how should it be represented?\n\nEntries should be returned as a preference-ordered array of representations. Each representation\nconsists of a string and some HTML; the string should represent the HTML's content if all\nformatting were stripped. Items are compared for string equality, with later suggestions used in\ncase of overlap, but the HTML is what's displayed. Exceptions are logged as errors during HTML\ngeneration.\n\nThe empty array means that the block should not be included.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"localContentItem","kind":{"const":{"docs":"Should this block be an entry in the page-local ToC? If so, how should it be represented?\n\nEntries should be returned as a preference-ordered array of representations. Each representation\nconsists of a string and some HTML; the string should represent the HTML's content if all\nformatting were stripped. Items are compared for string equality, with later suggestions used in\ncase of overlap, but the HTML is what's displayed. Exceptions are logged as errors during HTML\ngeneration.\n\nThe empty array means that the block should not be included.\n","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","localContentItem"],"signature":"InternalId → Lean.Json → Array (Doc.Block Manual) → Except String (Array (String × Output.Html))"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.localContentItem","type":{"seq":{"highlights":[{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Except","kind":{"const":{"docs":"`Except ε α` is a type which represents either an error of type `ε` or a successful result with a\nvalue of type `α`.\n\n`Except ε : Type u → Type v` is a `Monad` that represents computations that may throw exceptions:\nthe `pure` operation is `Except.ok` and the `bind` operation returns the first encountered\n`Except.error`.\n","isDef":false,"name":["Except"],"signature":"Except.{u, v} (ε : Type u) (α : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How to generate TeX. If `none`, generating TeX from a document that contains this block will fail. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"toTeX","kind":{"const":{"docs":"How to generate TeX. If `none`, generating TeX from a document that contains this block will fail. ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","toTeX"],"signature":"Option (BlockToTeX Manual (ReaderT ExtensionImpls IO))"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.toTeX","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"BlockToTeX","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockToTeX"],"signature":"Verso.Genre.Manual.BlockToTeX (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Required TeX `\\usepackage` lines ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"usePackages","kind":{"const":{"docs":"Required TeX `\\usepackage` lines ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","usePackages"],"signature":"List String"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.usePackages","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Required items in the TeX preamble ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"preamble","kind":{"const":{"docs":"Required items in the TeX preamble ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","preamble"],"signature":"List String"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.preamble","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["toHtmlAssets","init","traverse","toHtml","localContentItem","toTeX","usePackages","preamble"],"isClass":false,"parents":[{"index":0,"name":"Verso.Genre.Manual.HtmlAssets","parent":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.toHtmlAssets"}]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.BlockDescr","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.BlockDescr","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":446,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Implementations of all the operations needed to use a block."}]},{"other":{"container":{"data":"Constructor","id":447,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Manual.BlockDescr.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockDescr","mk"],"signature":"Verso.Genre.Manual.BlockDescr.mk (toHtmlAssets : HtmlAssets) (init : TraverseState → TraverseState)\n (traverse : BlockTraversal Manual)\n (toHtml : Option (BlockToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO))))\n (localContentItem : InternalId → Lean.Json → Array (Doc.Block Manual) → Except String (Array (String × Output.Html)))\n (toTeX : Option (BlockToTeX Manual (ReaderT ExtensionImpls IO))) (usePackages preamble : List String) : BlockDescr"}}}}},null],"id":448,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Extends","id":449,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["Verso.Genre.Manual.BlockDescr",[{"index":0,"name":"Verso.Genre.Manual.HtmlAssets","parent":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"projFn":"Verso.Genre.Manual.BlockDescr.toHtmlAssets"}]],"id":450,"name":"Verso.Genre.Manual.Block.inheritance","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":451,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraCss","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CSS","kind":{"const":{"docs":"Cascading Stylesheet code\\.\n","isDef":false,"name":["Verso","Genre","Manual","CSS"],"signature":"Verso.Genre.Manual.CSS : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":452,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraJs","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JS","kind":{"const":{"docs":"JavaScript code\\.\n","isDef":false,"name":["Verso","Genre","Manual","JS"],"signature":"Verso.Genre.Manual.JS : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":453,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraJsFiles","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JsFile","kind":{"const":{"docs":"An extra JS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","JsFile"],"signature":"Verso.Genre.Manual.JsFile : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":454,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraCssFiles","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CssFile","kind":{"const":{"docs":"An extra CSS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","CssFile"],"signature":"Verso.Genre.Manual.CssFile : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":455,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraDataFiles","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"DataFile","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","DataFile"],"signature":"Verso.Genre.Manual.DataFile : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":456,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"licenseInfo","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"LicenseInfo","kind":{"const":{"docs":"A description of an open-source license used by a frontend component that's included in\ngenerated HTML. This is used to create an attribution page.\n","isDef":false,"name":["Verso","Genre","Manual","LicenseInfo"],"signature":"Verso.Genre.Manual.LicenseInfo : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":457,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"init","kind":{"const":{"docs":"All registered initializers are called in the state prior to the first traversal. ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","init"],"signature":"TraverseState → TraverseState"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":458,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"All registered initializers are called in the state prior to the first traversal."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"traverse","kind":{"const":{"docs":"How the traversal phase should process this block ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","traverse"],"signature":"BlockTraversal Manual"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"BlockTraversal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockTraversal"],"signature":"Verso.Genre.Manual.BlockTraversal (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":459,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How the traversal phase should process this block"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"toHtml","kind":{"const":{"docs":"How to generate HTML. If `none`, generating HTML from a document that contains this block will fail.\n","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","toHtml"],"signature":"Option (BlockToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO)))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"BlockToHtml","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockToHtml"],"signature":"Verso.Genre.Manual.BlockToHtml (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Multi.AllRemotes","kind":{"const":{"docs":"All remote data that was loaded\\.\n","isDef":false,"name":["Verso","Multi","AllRemotes"],"signature":"Verso.Multi.AllRemotes : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":460,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to generate HTML. If "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":461,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", generating HTML from a document that contains this block will fail."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"localContentItem","kind":{"const":{"docs":"Should this block be an entry in the page-local ToC? If so, how should it be represented?\n\nEntries should be returned as a preference-ordered array of representations. Each representation\nconsists of a string and some HTML; the string should represent the HTML's content if all\nformatting were stripped. Items are compared for string equality, with later suggestions used in\ncase of overlap, but the HTML is what's displayed. Exceptions are logged as errors during HTML\ngeneration.\n\nThe empty array means that the block should not be included.\n","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","localContentItem"],"signature":"InternalId → Lean.Json → Array (Doc.Block Manual) → Except String (Array (String × Output.Html))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Block","kind":{"const":{"docs":"Block-level content in a document.\n","isDef":false,"name":["Verso","Doc","Block"],"signature":"Verso.Doc.Block (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Except","kind":{"const":{"docs":"`Except ε α` is a type which represents either an error of type `ε` or a successful result with a\nvalue of type `α`.\n\n`Except ε : Type u → Type v` is a `Monad` that represents computations that may throw exceptions:\nthe `pure` operation is `Except.ok` and the `bind` operation returns the first encountered\n`Except.error`.\n","isDef":false,"name":["Except"],"signature":"Except.{u, v} (ε : Type u) (α : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":462,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Should this block be an entry in the page-local ToC? If so, how should it be represented?"}]},{"para":[{"text":"Entries should be returned as a preference-ordered array of representations. Each representation"},{"text":"\n"},{"text":"consists of a string and some HTML; the string should represent the HTML's content if all"},{"text":"\n"},{"text":"formatting were stripped. Items are compared for string equality, with later suggestions used in"},{"text":"\n"},{"text":"case of overlap, but the HTML is what's displayed. Exceptions are logged as errors during HTML"},{"text":"\n"},{"text":"generation."}]},{"para":[{"text":"The empty array means that the block should not be included."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"toTeX","kind":{"const":{"docs":"How to generate TeX. If `none`, generating TeX from a document that contains this block will fail. ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","toTeX"],"signature":"Option (BlockToTeX Manual (ReaderT ExtensionImpls IO))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"BlockToTeX","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","BlockToTeX"],"signature":"Verso.Genre.Manual.BlockToTeX (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":463,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to generate TeX. If "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":464,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", generating TeX from a document that contains this block will fail."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"usePackages","kind":{"const":{"docs":"Required TeX `\\usepackage` lines ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","usePackages"],"signature":"List String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":465,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Required TeX "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"\\","kind":"unknown"}}},{"token":{"tok":{"content":"usepackage","kind":"unknown"}}}]}},"id":466,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\\usepackage"}]}},{"text":" lines"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"preamble","kind":{"const":{"docs":"Required items in the TeX preamble ","isDef":true,"name":["Verso","Genre","Manual","BlockDescr","preamble"],"signature":"List String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":467,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Required items in the TeX preamble"}]}]}}]}}]}}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.InlineDescr",[{"structure":{"ancestors":["Verso.Genre.Manual.HtmlAssets"],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.InlineDescr.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineDescr","mk"],"signature":"Verso.Genre.Manual.InlineDescr.mk (toHtmlAssets : HtmlAssets) (init : TraverseState → TraverseState)\n (traverse : InlineTraversal Manual)\n (toHtml : Option (InlineToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO))))\n (localContentItem : InternalId → Lean.Json → Array (Doc.Inline Manual) → Except String (Array (String × Output.Html)))\n (toTeX : Option (InlineToTeX Manual (ReaderT ExtensionImpls IO))) (usePackages preamble : List String) : InlineDescr"}}}}},"name":"Verso.Genre.Manual.InlineDescr.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.InlineDescr.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"toHtmlAssets","kind":{"var":{"name":"_uniq.444","type":"HtmlAssets"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"init","kind":{"var":{"name":"_uniq.446","type":"TraverseState → TraverseState"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"traverse","kind":{"var":{"name":"_uniq.448","type":"InlineTraversal Manual"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"InlineTraversal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineTraversal"],"signature":"Verso.Genre.Manual.InlineTraversal (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"toHtml","kind":{"var":{"name":"_uniq.457","type":"Option (InlineToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO)))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"InlineToHtml","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineToHtml"],"signature":"Verso.Genre.Manual.InlineToHtml (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Multi.AllRemotes","kind":{"const":{"docs":"All remote data that was loaded\\.\n","isDef":false,"name":["Verso","Multi","AllRemotes"],"signature":"Verso.Multi.AllRemotes : Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"localContentItem","kind":{"var":{"name":"_uniq.464","type":"InternalId → Lean.Json → Array (Doc.Inline Manual) → Except String (Array (String × Output.Html))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Except","kind":{"const":{"docs":"`Except ε α` is a type which represents either an error of type `ε` or a successful result with a\nvalue of type `α`.\n\n`Except ε : Type u → Type v` is a `Monad` that represents computations that may throw exceptions:\nthe `pure` operation is `Except.ok` and the `bind` operation returns the first encountered\n`Except.error`.\n","isDef":false,"name":["Except"],"signature":"Except.{u, v} (ε : Type u) (α : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"toTeX","kind":{"var":{"name":"_uniq.469","type":"Option (InlineToTeX Manual (ReaderT ExtensionImpls IO))"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"InlineToTeX","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineToTeX"],"signature":"Verso.Genre.Manual.InlineToTeX (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"usePackages","kind":{"var":{"name":"_uniq.470","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"preamble","kind":{"var":{"name":"_uniq.471","type":"List String"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"InlineDescr","kind":{"const":{"docs":"Implementations of all the operations needed to use an inline element. ","isDef":false,"name":["Verso","Genre","Manual","InlineDescr"],"signature":"Verso.Genre.Manual.InlineDescr : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"toHtmlAssets","kind":{"const":{"docs":null,"isDef":true,"name":["Verso","Genre","Manual","InlineDescr","toHtmlAssets"],"signature":"HtmlAssets"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.toHtmlAssets","subobject":"Verso.Genre.Manual.HtmlAssets","type":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraCss","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CSS","kind":{"const":{"docs":"Cascading Stylesheet code\\.\n","isDef":false,"name":["Verso","Genre","Manual","CSS"],"signature":"Verso.Genre.Manual.CSS : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraJs","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JS","kind":{"const":{"docs":"JavaScript code\\.\n","isDef":false,"name":["Verso","Genre","Manual","JS"],"signature":"Verso.Genre.Manual.JS : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraJsFiles","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JsFile","kind":{"const":{"docs":"An extra JS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","JsFile"],"signature":"Verso.Genre.Manual.JsFile : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraCssFiles","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CssFile","kind":{"const":{"docs":"An extra CSS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","CssFile"],"signature":"Verso.Genre.Manual.CssFile : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"extraDataFiles","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"DataFile","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","DataFile"],"signature":"Verso.Genre.Manual.DataFile : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","fieldFrom":[{"docstring":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"name":"Verso.Genre.Manual.HtmlAssets","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}}],"fieldName":{"token":{"tok":{"content":"licenseInfo","kind":"unknown"}}},"projFn":"[anonymous]","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"LicenseInfo","kind":{"const":{"docs":"A description of an open-source license used by a frontend component that's included in\ngenerated HTML. This is used to create an attribution page.\n","isDef":false,"name":["Verso","Genre","Manual","LicenseInfo"],"signature":"Verso.Genre.Manual.LicenseInfo : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"All registered initializers are called in the state prior to the first traversal. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"init","kind":{"const":{"docs":"All registered initializers are called in the state prior to the first traversal. ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","init"],"signature":"TraverseState → TraverseState"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.init","type":{"seq":{"highlights":[{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Given the contents of the `data` field of the corresponding `Manual.Inline` and the contained\ninline elements, carry out the traversal pass.\n\nIn addition to updating the cross-reference state through the available monadic effects, a\ntraversal may additionally replace the element with another one. This can be used to e.g. emit\na cross-reference once the target becomes available in the state. To replace the element,\nreturn `some`. To leave it as is, return `none`.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"traverse","kind":{"const":{"docs":"Given the contents of the `data` field of the corresponding `Manual.Inline` and the contained\ninline elements, carry out the traversal pass.\n\nIn addition to updating the cross-reference state through the available monadic effects, a\ntraversal may additionally replace the element with another one. This can be used to e.g. emit\na cross-reference once the target becomes available in the state. To replace the element,\nreturn `some`. To leave it as is, return `none`.\n","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","traverse"],"signature":"InlineTraversal Manual"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.traverse","type":{"seq":{"highlights":[{"token":{"tok":{"content":"InlineTraversal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineTraversal"],"signature":"Verso.Genre.Manual.InlineTraversal (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How to generate HTML. If `none`, generating HTML from a document that contains this inline will fail.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"toHtml","kind":{"const":{"docs":"How to generate HTML. If `none`, generating HTML from a document that contains this inline will fail.\n","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","toHtml"],"signature":"Option (InlineToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO)))"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.toHtml","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"InlineToHtml","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineToHtml"],"signature":"Verso.Genre.Manual.InlineToHtml (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Multi.AllRemotes","kind":{"const":{"docs":"All remote data that was loaded\\.\n","isDef":false,"name":["Verso","Multi","AllRemotes"],"signature":"Verso.Multi.AllRemotes : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Should this inline be an entry in the page-local ToC? If so, how should it be represented?\n\nEntries should be returned as a preference-ordered array of representations. Each representation\nconsists of a string and some HTML; the string should represent the HTML's content if all\nformatting were stripped. Items are compared for string equality, with later suggestions used in\ncase of overlap, but the HTML is what's displayed.\n\nThe empty array means that the inline should not be included.\n","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"localContentItem","kind":{"const":{"docs":"Should this inline be an entry in the page-local ToC? If so, how should it be represented?\n\nEntries should be returned as a preference-ordered array of representations. Each representation\nconsists of a string and some HTML; the string should represent the HTML's content if all\nformatting were stripped. Items are compared for string equality, with later suggestions used in\ncase of overlap, but the HTML is what's displayed.\n\nThe empty array means that the inline should not be included.\n","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","localContentItem"],"signature":"InternalId → Lean.Json → Array (Doc.Inline Manual) → Except String (Array (String × Output.Html))"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.localContentItem","type":{"seq":{"highlights":[{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Except","kind":{"const":{"docs":"`Except ε α` is a type which represents either an error of type `ε` or a successful result with a\nvalue of type `α`.\n\n`Except ε : Type u → Type v` is a `Monad` that represents computations that may throw exceptions:\nthe `pure` operation is `Except.ok` and the `bind` operation returns the first encountered\n`Except.error`.\n","isDef":false,"name":["Except"],"signature":"Except.{u, v} (ε : Type u) (α : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"How to generate TeX. If `none`, generating TeX from a document that contains this inline will fail. ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"toTeX","kind":{"const":{"docs":"How to generate TeX. If `none`, generating TeX from a document that contains this inline will fail. ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","toTeX"],"signature":"Option (InlineToTeX Manual (ReaderT ExtensionImpls IO))"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.toTeX","type":{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"InlineToTeX","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineToTeX"],"signature":"Verso.Genre.Manual.InlineToTeX (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Required TeX `\\usepackage` lines ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"usePackages","kind":{"const":{"docs":"Required TeX `\\usepackage` lines ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","usePackages"],"signature":"List String"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.usePackages","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"},{"autoParam":false,"binderInfo":"default","docString":"Required items in the TeX preamble ","fieldFrom":[],"fieldName":{"token":{"tok":{"content":"preamble","kind":{"const":{"docs":"Required items in the TeX preamble ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","preamble"],"signature":"List String"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.preamble","type":{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},"visibility":"public"}],"fieldNames":["toHtmlAssets","init","traverse","toHtml","localContentItem","toTeX","usePackages","preamble"],"isClass":false,"parents":[{"index":0,"name":"Verso.Genre.Manual.HtmlAssets","parent":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.toHtmlAssets"}]}},[{"narrow":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.InlineDescr","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}},"wide":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.InlineDescr","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Type","kind":{"sort":{"doc?":"A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`. "}}}}}]}}},[null,[]]]]],"id":468,"name":"Verso.Genre.Manual.Block.docstring","properties":{}},"content":[{"para":[{"text":"Implementations of all the operations needed to use an inline element."}]},{"other":{"container":{"data":"Constructor","id":469,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":[{"token":{"tok":{"content":"Verso.Genre.Manual.InlineDescr.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineDescr","mk"],"signature":"Verso.Genre.Manual.InlineDescr.mk (toHtmlAssets : HtmlAssets) (init : TraverseState → TraverseState)\n (traverse : InlineTraversal Manual)\n (toHtml : Option (InlineToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO))))\n (localContentItem : InternalId → Lean.Json → Array (Doc.Inline Manual) → Except String (Array (String × Output.Html)))\n (toTeX : Option (InlineToTeX Manual (ReaderT ExtensionImpls IO))) (usePackages preamble : List String) : InlineDescr"}}}}},null],"id":470,"name":"Verso.Genre.Manual.Block.internalSignature","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Extends","id":471,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["Verso.Genre.Manual.InlineDescr",[{"index":0,"name":"Verso.Genre.Manual.HtmlAssets","parent":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"projFn":"Verso.Genre.Manual.InlineDescr.toHtmlAssets"}]],"id":472,"name":"Verso.Genre.Manual.Block.inheritance","properties":{}},"content":[]}}]}},{"other":{"container":{"data":"Fields","id":473,"name":"Verso.Genre.Manual.Block.docstringSection","properties":{}},"content":[{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraCss","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CSS","kind":{"const":{"docs":"Cascading Stylesheet code\\.\n","isDef":false,"name":["Verso","Genre","Manual","CSS"],"signature":"Verso.Genre.Manual.CSS : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":474,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraJs","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JS","kind":{"const":{"docs":"JavaScript code\\.\n","isDef":false,"name":["Verso","Genre","Manual","JS"],"signature":"Verso.Genre.Manual.JS : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":475,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraJsFiles","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JsFile","kind":{"const":{"docs":"An extra JS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","JsFile"],"signature":"Verso.Genre.Manual.JsFile : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":476,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraCssFiles","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CssFile","kind":{"const":{"docs":"An extra CSS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","CssFile"],"signature":"Verso.Genre.Manual.CssFile : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":477,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"extraDataFiles","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"DataFile","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","DataFile"],"signature":"Verso.Genre.Manual.DataFile : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":478,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"licenseInfo","kind":"unknown"}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"LicenseInfo","kind":{"const":{"docs":"A description of an open-source license used by a frontend component that's included in\ngenerated HTML. This is used to create an attribution page.\n","isDef":false,"name":["Verso","Genre","Manual","LicenseInfo"],"signature":"Verso.Genre.Manual.LicenseInfo : Type"}}}}}]}},[0,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":479,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"init","kind":{"const":{"docs":"All registered initializers are called in the state prior to the first traversal. ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","init"],"signature":"TraverseState → TraverseState"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":480,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"All registered initializers are called in the state prior to the first traversal."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"traverse","kind":{"const":{"docs":"Given the contents of the `data` field of the corresponding `Manual.Inline` and the contained\ninline elements, carry out the traversal pass.\n\nIn addition to updating the cross-reference state through the available monadic effects, a\ntraversal may additionally replace the element with another one. This can be used to e.g. emit\na cross-reference once the target becomes available in the state. To replace the element,\nreturn `some`. To leave it as is, return `none`.\n","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","traverse"],"signature":"InlineTraversal Manual"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"InlineTraversal","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineTraversal"],"signature":"Verso.Genre.Manual.InlineTraversal (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":481,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Given the contents of the "},{"other":{"container":{"data":{"token":{"tok":{"content":"data","kind":"unknown"}}},"id":482,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"data"}]}},{"text":" field of the corresponding "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual.Inline","kind":{"const":{"docs":"A custom inline. The `name` field should correspond to an entry in the block descriptions table.\n","isDef":false,"name":["Verso","Genre","Manual","Inline"],"signature":"Verso.Genre.Manual.Inline : Type"}}}}},"id":483,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"Manual.Inline"}]}},{"text":" and the contained"},{"text":"\n"},{"text":"inline elements, carry out the traversal pass."}]},{"para":[{"text":"In addition to updating the cross-reference state through the available monadic effects, a"},{"text":"\n"},{"text":"traversal may additionally replace the element with another one. This can be used to e.g. emit"},{"text":"\n"},{"text":"a cross-reference once the target becomes available in the state. To replace the element,"},{"text":"\n"},{"text":"return "},{"other":{"container":{"data":{"token":{"tok":{"content":"some","kind":{"const":{"docs":"Some value of type `α`. ","isDef":false,"name":["Option","some"],"signature":"Option.some.{u} {α : Type u} (val : α) : Option α"}}}}},"id":484,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"some"}]}},{"text":". To leave it as is, return "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":485,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":"."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"toHtml","kind":{"const":{"docs":"How to generate HTML. If `none`, generating HTML from a document that contains this inline will fail.\n","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","toHtml"],"signature":"Option (InlineToHtml Manual (ReaderT Multi.AllRemotes (ReaderT ExtensionImpls IO)))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"InlineToHtml","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineToHtml"],"signature":"Verso.Genre.Manual.InlineToHtml (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Multi.AllRemotes","kind":{"const":{"docs":"All remote data that was loaded\\.\n","isDef":false,"name":["Verso","Multi","AllRemotes"],"signature":"Verso.Multi.AllRemotes : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":486,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to generate HTML. If "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":487,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", generating HTML from a document that contains this inline will fail."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"localContentItem","kind":{"const":{"docs":"Should this inline be an entry in the page-local ToC? If so, how should it be represented?\n\nEntries should be returned as a preference-ordered array of representations. Each representation\nconsists of a string and some HTML; the string should represent the HTML's content if all\nformatting were stripped. Items are compared for string equality, with later suggestions used in\ncase of overlap, but the HTML is what's displayed.\n\nThe empty array means that the inline should not be included.\n","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","localContentItem"],"signature":"InternalId → Lean.Json → Array (Doc.Inline Manual) → Except String (Array (String × Output.Html))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"InternalId","kind":{"const":{"docs":"An internal identifier assigned to a part during traversal. Users don't get to have influence\nover these IDs, so they can be used to ensure uniqueness of tags.\n\nEven though the constructor is private, there is a JSON serialization that can be used to undermine\nthe uniqueness of internal IDs. Please don't do that - your program may break unpredictably.\n","isDef":false,"name":["Verso","Multi","InternalId"],"signature":"Verso.Multi.InternalId : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Lean.Json","kind":{"const":{"docs":null,"isDef":false,"name":["Lean","Json"],"signature":"Lean.Json : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Doc.Inline","kind":{"const":{"docs":"Inline content that is part of the text flow.\n","isDef":false,"name":["Verso","Doc","Inline"],"signature":"Verso.Doc.Inline (genre : Genre) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"→","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Except","kind":{"const":{"docs":"`Except ε α` is a type which represents either an error of type `ε` or a successful result with a\nvalue of type `α`.\n\n`Except ε : Type u → Type v` is a `Monad` that represents computations that may throw exceptions:\nthe `pure` operation is `Except.ok` and the `bind` operation returns the first encountered\n`Except.error`.\n","isDef":false,"name":["Except"],"signature":"Except.{u, v} (ε : Type u) (α : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"Array","kind":{"const":{"docs":"`Array α` is the type of [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array) with elements\nfrom `α`. This type has special support in the runtime.\n\nArrays perform best when unshared. As long as there is never more than one reference to an array,\nall updates will be performed _destructively_. This results in performance comparable to mutable\narrays in imperative programming languages.\n\nAn array has a size and a capacity. The size is the number of elements present in the array, while\nthe capacity is the amount of memory currently allocated for elements. The size is accessible via\n`Array.size`, but the capacity is not observable from Lean code. `Array.emptyWithCapacity n` creates\nan array which is equal to `#[]`, but internally allocates an array of capacity `n`. When the size\nexceeds the capacity, allocation is required to grow the array.\n\nFrom the point of view of proofs, `Array α` is just a wrapper around `List α`.\n","isDef":false,"name":["Array"],"signature":"Array.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"×","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Output.Html","kind":{"const":{"docs":"A representation of HTML, used to render Verso to the web.\n","isDef":false,"name":["Verso","Output","Html"],"signature":"Verso.Output.Html : Type"}}}}},{"token":{"tok":{"content":")","kind":{"const":{"docs":"The product type, usually written `α × β`. Product types are also called pair or tuple types.\nElements of this type are pairs in which the first element is an `α` and the second element is a\n`β`.\n\nProducts nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.\n\n\nConventions for notations in identifiers:\n\n * The recommended spelling of `×` in identifiers is `Prod`.","isDef":false,"name":["Prod"],"signature":"Prod.{u, v} (α : Type u) (β : Type v) : Type (max u v)"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":488,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Should this inline be an entry in the page-local ToC? If so, how should it be represented?"}]},{"para":[{"text":"Entries should be returned as a preference-ordered array of representations. Each representation"},{"text":"\n"},{"text":"consists of a string and some HTML; the string should represent the HTML's content if all"},{"text":"\n"},{"text":"formatting were stripped. Items are compared for string equality, with later suggestions used in"},{"text":"\n"},{"text":"case of overlap, but the HTML is what's displayed."}]},{"para":[{"text":"The empty array means that the inline should not be included."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"toTeX","kind":{"const":{"docs":"How to generate TeX. If `none`, generating TeX from a document that contains this inline will fail. ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","toTeX"],"signature":"Option (InlineToTeX Manual (ReaderT ExtensionImpls IO))"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"Option","kind":{"const":{"docs":"Optional values, which are either `some` around a value from the underlying type or `none`.\n\n`Option` can represent nullable types or computations that might fail. In the codomain of a function\ntype, it can also represent partiality.\n","isDef":false,"name":["Option"],"signature":"Option.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"InlineToTeX","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","InlineToTeX"],"signature":"Verso.Genre.Manual.InlineToTeX (genre : Genre) (m : Type → Type) : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Manual","kind":{"const":{"docs":"A genre for writing reference manuals and other book-like documents. ","isDef":false,"name":["Verso","Genre","Manual"],"signature":"Verso.Genre.Manual : Genre"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"ReaderT","kind":{"const":{"docs":"Adds the ability to access a read-only value of type `ρ` to a monad. The value can be locally\noverridden by `withReader`, but it cannot be mutated.\n\nActions in the resulting monad are functions that take the local value as a parameter, returning\nordinary actions in `m`.\n","isDef":false,"name":["ReaderT"],"signature":"ReaderT.{u, v} (ρ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v)"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"ExtensionImpls","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","ExtensionImpls"],"signature":"Verso.Genre.Manual.ExtensionImpls : Type"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"IO","kind":{"const":{"docs":"A monad that supports arbitrary side effects and throwing exceptions of type `IO.Error`.\n","isDef":false,"name":["IO"],"signature":"IO : Type → Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"token":{"tok":{"content":")","kind":"unknown"}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":489,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"How to generate TeX. If "},{"other":{"container":{"data":{"token":{"tok":{"content":"none","kind":{"const":{"docs":"No value. ","isDef":false,"name":["Option","none"],"signature":"Option.none.{u} {α : Type u} : Option α"}}}}},"id":490,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"none"}]}},{"text":", generating TeX from a document that contains this inline will fail."}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"usePackages","kind":{"const":{"docs":"Required TeX `\\usepackage` lines ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","usePackages"],"signature":"List String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":491,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Required TeX "},{"other":{"container":{"data":{"seq":{"highlights":[{"token":{"tok":{"content":"\\","kind":"unknown"}}},{"token":{"tok":{"content":"usepackage","kind":"unknown"}}}]}},"id":492,"name":"Verso.Genre.Manual.leanFromMarkdown"},"content":[{"code":"\\usepackage"}]}},{"text":" lines"}]}]}},{"other":{"container":{"data":["public",[{"token":{"tok":{"content":"preamble","kind":{"const":{"docs":"Required items in the TeX preamble ","isDef":true,"name":["Verso","Genre","Manual","InlineDescr","preamble"],"signature":"List String"}}}}},[{"seq":{"highlights":[{"token":{"tok":{"content":"List","kind":{"const":{"docs":"Linked lists: ordered lists, in which each element has a reference to the next element.\n\nMost operations on linked lists take time proportional to the length of the list, because each\nelement must be traversed to find the next element.\n\n`List α` is isomorphic to `Array α`, but they are useful for different things:\n* `List α` is easier for reasoning, and `Array α` is modeled as a wrapper around `List α`.\n* `List α` works well as a persistent data structure, when many copies of the tail are shared. When\n the value is not shared, `Array α` will have better performance because it can do destructive\n updates.\n","isDef":false,"name":["List"],"signature":"List.{u} (α : Type u) : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"String","kind":{"const":{"docs":"A string is a sequence of Unicode scalar values.\n\nAt runtime, strings are represented by [dynamic arrays](https://en.wikipedia.org/wiki/Dynamic_array)\nof bytes using the UTF-8 encoding. Both the size in bytes (`String.utf8ByteSize`) and in characters\n(`String.length`) are cached and take constant time. Many operations on strings perform in-place\nmodifications when the reference to the string is unique.\n","isDef":false,"name":["String"],"signature":"String : Type"}}}}}]}},[null,[{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]]]]],"id":493,"name":"Verso.Genre.Manual.Block.fieldSignature","properties":{}},"content":[{"para":[{"text":"Required items in the TeX preamble"}]}]}}]}}]}}]},{"para":[{"text":"Typically, the "},{"code":"inline_extension"},{"text":" and "},{"code":"block_extension"},{"text":" commands are used to simultaneously define an element and its descriptor, registering them for use by "},{"other":{"container":{"data":{"token":{"tok":{"content":"manualMain","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","manualMain"],"signature":"Verso.Genre.Manual.manualMain (text : Part Manual) (extensionImpls : ExtensionImpls := by exact extension_impls%)\n (options : List String) (config : RenderConfig := { }) (extraSteps : List ExtraStep := []) : IO UInt32"}}}}},"id":494,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"manualMain"}]}},{"text":"."}]},{"concat":[{"other":{"container":{"data":null,"id":495,"name":"Verso.Genre.Manual.Block.paragraph","properties":{}},"content":[{"para":[{"text":"The type "},{"other":{"container":{"data":{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}},"id":496,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"HtmlAssets"}]}},{"text":" contains CSS and JavaScript code."},{"linebreak":"\n"},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual.TraverseState","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","TraverseState"],"signature":"Verso.Genre.Manual.TraverseState : Type"}}}}},"id":497,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual.TraverseState"}]}},{"text":", "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual.BlockDescr","kind":{"const":{"docs":"Implementations of all the operations needed to use a block.\n","isDef":false,"name":["Verso","Genre","Manual","BlockDescr"],"signature":"Verso.Genre.Manual.BlockDescr : Type"}}}}},"id":498,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual.BlockDescr"}]}},{"text":", and "},{"other":{"container":{"data":{"token":{"tok":{"content":"Manual.InlineDescr","kind":{"const":{"docs":"Implementations of all the operations needed to use an inline element. ","isDef":false,"name":["Verso","Genre","Manual","InlineDescr"],"signature":"Verso.Genre.Manual.InlineDescr : Type"}}}}},"id":499,"name":"Verso.Genre.Manual.InlineLean.Inline.name"},"content":[{"code":"Manual.InlineDescr"}]}},{"text":" all inherit from this structure."},{"linebreak":"\n"},{"text":"During traversal, HTML assets are collected; they are all included in the final rendered document."}]},{"concat":[{"other":{"container":{"data":["Verso.Genre.Manual.HtmlAssets",[{"structure":{"ancestors":[],"constructor":{"hlName":{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets.mk","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","HtmlAssets","mk"],"signature":"Verso.Genre.Manual.HtmlAssets.mk (extraCss : Std.HashSet CSS) (extraJs : Std.HashSet JS)\n (extraJsFiles : Std.HashSet JsFile) (extraCssFiles : Std.HashSet CssFile) (extraDataFiles : Std.HashSet DataFile)\n (licenseInfo : Std.HashSet LicenseInfo) : HtmlAssets"}}}}},"name":"Verso.Genre.Manual.HtmlAssets.mk","signature":{"seq":{"highlights":[{"token":{"tok":{"content":"Verso.Genre.Manual.HtmlAssets.mk","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"extraCss","kind":{"var":{"name":"_uniq.628","type":"Std.HashSet CSS"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CSS","kind":{"const":{"docs":"Cascading Stylesheet code\\.\n","isDef":false,"name":["Verso","Genre","Manual","CSS"],"signature":"Verso.Genre.Manual.CSS : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"extraJs","kind":{"var":{"name":"_uniq.632","type":"Std.HashSet JS"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JS","kind":{"const":{"docs":"JavaScript code\\.\n","isDef":false,"name":["Verso","Genre","Manual","JS"],"signature":"Verso.Genre.Manual.JS : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"extraJsFiles","kind":{"var":{"name":"_uniq.636","type":"Std.HashSet JsFile"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"JsFile","kind":{"const":{"docs":"An extra JS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","JsFile"],"signature":"Verso.Genre.Manual.JsFile : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"extraCssFiles","kind":{"var":{"name":"_uniq.640","type":"Std.HashSet CssFile"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"CssFile","kind":{"const":{"docs":"An extra CSS file to be emitted and added to the page.\n","isDef":false,"name":["Verso","Genre","Manual","CssFile"],"signature":"Verso.Genre.Manual.CssFile : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"extraDataFiles","kind":{"var":{"name":"_uniq.644","type":"Std.HashSet DataFile"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"DataFile","kind":{"const":{"docs":null,"isDef":false,"name":["Verso","Genre","Manual","DataFile"],"signature":"Verso.Genre.Manual.DataFile : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"(","kind":"unknown"}}},{"token":{"tok":{"content":"licenseInfo","kind":{"var":{"name":"_uniq.648","type":"Std.HashSet LicenseInfo"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"Std.HashSet","kind":{"const":{"docs":"Hash sets.\n\nThis is a simple separate-chaining hash table. The data of the hash set consists of a cached size\nand an array of buckets, where each bucket is a linked list of keys. The number of buckets\nis always a power of two. The hash set doubles its size upon inserting an element such that the\nnumber of elements is more than 75% of the number of buckets.\n\nThe hash table is backed by an `Array`. Users should make sure that the hash set is used linearly to\navoid expensive copies.\n\nThe hash set uses `==` (provided by the `BEq` typeclass) to compare elements and `hash` (provided by\nthe `Hashable` typeclass) to hash them. To ensure that the operations behave as expected, `==`\nshould be an equivalence relation and `a == b` should imply `hash a = hash b` (see also the\n`EquivBEq` and `LawfulHashable` typeclasses). Both of these conditions are automatic if the BEq\ninstance is lawful, i.e., if `a == b` implies `a = b`.\n\nThese hash sets contain a bundled well-formedness invariant, which means that they cannot\nbe used in nested inductive types. For these use cases, `Std.Data.HashSet.Raw` and\n`Std.Data.HashSet.Raw.WF` unbundle the invariant from the hash set. When in doubt, prefer\n`HashSet` over `HashSet.Raw`.\n","isDef":false,"name":["Std","HashSet"],"signature":"Std.HashSet.{u} (α : Type u) [BEq α] [Hashable α] : Type u"}}}}},{"text":{"str":" "}},{"token":{"tok":{"content":"LicenseInfo","kind":{"const":{"docs":"A description of an open-source license used by a frontend component that's included in\ngenerated HTML. This is used to create an attribution page.\n","isDef":false,"name":["Verso","Genre","Manual","LicenseInfo"],"signature":"Verso.Genre.Manual.LicenseInfo : Type"}}}}},{"token":{"tok":{"content":")","kind":"unknown"}}},{"text":{"str":" "}},{"token":{"tok":{"content":":","kind":"unknown"}}},{"text":{"str":"\n "}},{"token":{"tok":{"content":"HtmlAssets","kind":{"const":{"docs":"A collection of HTML assets that can be initialized in the manual configuration and enlarged by\ncustom elements during traversal\\.\n","isDef":false,"name":["Verso","Genre","Manual","HtmlAssets"],"signature":"Verso.Genre.Manual.HtmlAssets : Type"}}}}}]}}},"fieldInfo":[{"autoParam":false,"binderInfo":"default","docString":"Extra CSS to be included inline into every `` via `