The command-line tool fsdocs can be used to generate documentation
+for F# libraries with XML comments. The documentation is normally built using fsdocs build and developed using fsdocs watch. For
+the former the output will be placed in output\reference by default.
Arbitrary paragraph-level HTML such as <b> for bold in XML doc text
+
<namespacedoc> giving documentation for the enclosing namespace
+
<exclude/> to exclude from XML docs
+
+
<category> to give a category for an entity or member. An optional index attribute can be specified
+to help sort the list of categories.
+
+
+
\(...\) for inline math and $$...$$ and \[...\]for math environments, see http://docs.mathjax.org.
+Some escaping of characters (e.g. <, >) may be needed to form valid XML
+
+
+
An example of an XML documentation comment, assuming the code is in namespace TheNamespace:
+
/// <summary>
+/// A module
+/// </summary>
+///
+/// <namespacedoc>
+/// <summary>A namespace to remember</summary>
+///
+/// <remarks>More on that</remarks>
+/// </namespacedoc>
+///
+moduleSomeModule=
+ /// <summary>
+ /// Some actual comment
+ /// <para>Another paragraph, see <see cref="T:TheNamespace.SomeType"/>. </para>
+ /// </summary>
+ ///
+ /// <param name="x">The input</param>
+ ///
+ /// <returns>The output</returns>
+ ///
+ /// <example>
+ /// Try using
+ /// <code>
+ /// open TheNamespace
+ /// SomeModule.a
+ /// </code>
+ /// </example>
+ ///
+ /// <category>Foo</category>
+ letsomeFunctionx=42+x
+
+/// <summary>
+/// A type, see <see cref="T:TheNamespace.SomeModule"/> and
+/// <see cref="M:TheNamespace.SomeModule.someFunction"/>.
+/// </summary>
+///
+typeSomeType()=
+ memberx.P=1
+
+
Like types, members are referred to by xml doc sig. These must currently be precise as the F#
+compiler doesn't elaborate these references from simpler names:
If you want to exclude modules or functions from the API docs you can use the <exclude/> tag.
+It needs to be set on a separate triple-slashed line, and can either appear on its own or as part
+of an existing <summary> (for example, you may wish to hide existing documentation while it's in progress).
+The <exclude/> tag can be the first or last line in these cases.
+
Some examples:
+
/// <exclude/>
+moduleBottleKids1=
+ leta=42
+
+// Ordinary comment
+/// <exclude/>
+moduleBottleKids2=
+ leta=43
+
+/// <exclude/>
+/// BottleKids3 provides improvements over BottleKids2
+moduleBottleKids3=
+ leta=44
+
+/// BottleKids4 implements several new features over BottleKids3
+/// <exclude/>
+moduleBottleKids4=
+ leta=45
+
+/// <exclude/>
+/// <summary>
+/// BottleKids5 is all you'll ever need in terms of bottles or kids.
+/// </summary>
+moduleBottleKids5=
+ leta=46
+
+
Note that the comments for BottleKids3 (and BottleKids4) will generate a warning. This is because
+the <exclude/> tag will be parsed as part of the summary text, and so the documentation generator
+can't be completely sure you meant to exclude the item, or whether it was a valid part of the documentation.
+It will assume the exclusion was intended, but you may want to use explicit <summary> tags to remove
+the warning.
You will find that [omit] also works, but is considered part of the Markdown syntax and is
+deprecated for XML Doc comments. This will also produce a warning, such as this:
If your source is not built from the same project where you are building documentation then
+you may need these settings:
+
<FsDocsSourceRepository>...</FsDocsSourceRepository> -- the URL for the root of the source
+ <FsDocsSourceFolder>...</FsDocsSourceFolder> -- the root soure folder at time of build
+
+
It is assumed that sourceRepo and sourceFolder have synchronized contents.
You can use Markdown instead of XML in /// comments. If you do, you should set <UsesMarkdownComments>true</UsesMarkdownComments> in
+your F# project file.
+
+
Note: Markdown Comments are not supported in all F# IDE tooling.
You can automatically add cross-type links to the documentation pages of other modules and types in the same assembly.
+You can do this in two different ways:
+
+
+
Add a markdown inline link were the link
+title is the name of the type you want to link.
+
/// this will generate a link to [Foo.Bar] documentation
+
+
+
+
Add a Markdown inline code (using
+back-ticks) where the code is the name of the type you want to link.
+
/// This will also generate a link to `Foo.Bar` documentation
+
+
+
+
You can use either the full name (including namespace and module) or the simple name of a type.
+If more than one type is found with the same name the link will not be generated.
+If a type with the given name is not found in the same assembly the link will not be generated.
+
/// Contains two types [Bar] and [Foo.Baz]
+moduleFoo=
+
+ /// Bar is just an `int` and belongs to module [Foo]
+ typeBar=int
+
+ /// Baz contains a `Foo.Bar` as its `id`
+ typeBaz={id:Bar}
+
+ /// This function operates on `Baz` types.
+ letf(b:Baz)=b.id*42
+
+/// Referencing [Foo3] will not generate a link as there is no type with the name `Foo3`
+moduleFoo3=
+
+ /// This is not the same type as `Foo.Bar`
+ typeBar=double
+
+ /// Using the simple name for [Bar] will fail to create a link because the name is duplicated in
+ /// [Foo.Bar] and in [Foo3.Bar]. In this case, using the full name works.
+ letf2b=b*50
+
If you want to exclude modules or functions from the API docs you can use the [omit] tag.
+It needs to be set on a separate triple-slashed line, but it could be either the first or the last:
+
Example as last line:
+
/// Some actual comment
+/// [omit]
+moduleBar=
+ leta=42
+
+
Example as first line:
+
/// [omit]
+/// Some actual comment
+moduleBar2=
+ leta=42
+
You can build library documentation programatically using the functionality
+in the ApiDocs type. To do this, load the assembly and open necessary namespaces:
or use libDirs to include all assemblies from an entire folder.
+Tip: A combination of <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> in the fsproj file and setting libDirs to the compilation output path leads to only one folder with all dependencies referenced.
+This might be easier especially for large projects with many dependencies.
The root parameter is used for the base of page and image links in the generated documentation. By default it is derived from the project's <PackageProjectUrl> property.
+
In some instances, you may wish to override the value for root (perhaps for local testing). To do this, you can use the command-line argument --parameters root <base>.
val someFunction: x: int -> int <summary> Some actual comment <para>Another paragraph, see <see cref="T:TheNamespace.SomeType"/>. </para> </summary>
<param name="x">The input</param>
<returns>The output</returns>
<example> Try using <code> open TheNamespace SomeModule.a </code> </example>
<category>Foo</category>
+
val x: int
+
Multiple items type SomeType =
+ new: unit -> SomeType
+ member P: int <summary> A type, see <see cref="T:TheNamespace.SomeModule"/> and <see cref="M:TheNamespace.SomeModule.someFunction"/>. </summary>
-------------------- new: unit -> SomeType
+
val x: SomeType
+
member SomeType.P: int
+
Multiple items type Class2 =
+ new: unit -> Class2
+ member Method0: unit -> string
+ member Method1: c: string -> string
+ member Method2: c: string * o: obj -> string
+ member Property: string
-------------------- new: unit -> Class2
+
val this: Class2
+
val c: string
+
Multiple items val string: value: 'T -> string
-------------------- type string = System.String
+
val o: obj
+
type obj = System.Object
+
val referringFunction1: unit -> string <see cref="P:TheNamespace.Class2.Property" /> and <see cref="M:TheNamespace.Class2.OtherMethod0" /> and <see cref="M:TheNamespace.Class2.Method1(System.String)" /> and <see cref="M:TheNamespace.Class2.Method2(System.String,System.Object)" />
+
Multiple items type GenericClass2<'T> =
+ new: unit -> GenericClass2<'T>
+ member GenericMethod: _c: 'T * _o: 'U -> string
+ member NonGenericMethod: _c: 'T -> string
+ member Property: string
-------------------- new: unit -> GenericClass2<'T>
+
'T
+
val this: GenericClass2<'T>
+
val _c: 'T
+
val _o: 'U
+
'U
+
val referringFunction2: unit -> string See <see cref="T:TheNamespace.GenericClass2`1" /> and <see cref="P:TheNamespace.GenericClass2`1.Property" /> and <see cref="M:TheNamespace.GenericClass2`1.NonGenericMethod(`0)" /> and <see cref="M:TheNamespace.GenericClass2`1.GenericMethod``1(`0,``0)" />
+
val findFoxes: limit: int -> 'a list <summary> Find at most <c>limit</c> foxes in current forest
See also: <seealso cref="M:App.Forest.findSquirrels(System.Int32)"/> </summary>
+
val limit: int
+
Multiple items val int: value: 'T -> int (requires member op_Explicit)
-------------------- type int = int32
-------------------- type int<'Measure> =
+ int
+
val findSquirrels: limit: int -> 'a list <summary> Find at most <c>limit</c> squirrels in current forest
See also: <seealso cref="M:App.Forest.findFoxes(System.Int32)"/> </summary>
+
val a: int
+
type Bar = int Bar is just an `int` and belongs to module [Foo]
+
type Baz =
+ { id: Bar } Baz contains a `Foo.Bar` as its `id`
+
val id: x: 'T -> 'T
+
val f: b: Baz -> Bar This function operates on `Baz` types.
+
val b: Baz
+
Baz.id: Bar
+
type Bar = double This is not the same type as `Foo.Bar`
+
Multiple items val double: value: 'T -> double (requires member op_Explicit)
-------------------- type double = System.Double
-------------------- type double<'Measure> = float<'Measure>
+
val f2: b: int -> int Using the simple name for [Bar] will fail to create a link because the name is duplicated in [Foo.Bar] and in [Foo3.Bar]. In this case, using the full name works.
+
val b: int
+
Multiple items namespace FSharp
-------------------- namespace Microsoft.FSharp
+
namespace FSharp.Formatting
+
namespace FSharp.Formatting.ApiDocs
+
namespace System
+
namespace System.IO
+
val file: string
+
type Path =
+ static member ChangeExtension: path: string * extension: string -> string
+ static member Combine: path1: string * path2: string -> string + 3 overloads
+ static member EndsInDirectorySeparator: path: ReadOnlySpan<char> -> bool + 1 overload
+ static member Exists: path: string -> bool
+ static member GetDirectoryName: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetExtension: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetFileName: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetFileNameWithoutExtension: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetFullPath: path: string -> string + 1 overload
+ static member GetInvalidFileNameChars: unit -> char array
+ ... <summary>Performs operations on <see cref="T:System.String" /> instances that contain file or directory path information. These operations are performed in a cross-platform manner.</summary>
This page demonstrates how to use FSharp.Formatting.CodeFormat to tokenize
+F# source code, obtain information about the source code (mainly tooltips
+from the type-checker) and how to turn the code into a nicely formatted HTML.
+
First, we need to load the assembly and open necessary namespaces:
If you want to process multiple snippets, it is a good idea to keep the
+formatting agent around if possible. The agent needs to load the F# compiler
+(which needs to load various files itself) and so this takes a long time.
The formatting agent provides a CodeFormatAgent.ParseAndCheckSource method (together with an asynchronous
+version for use from F# and also a version that returns a .NET Task for C#).
+To call the method, we define a simple F# code as a string:
When calling the method, you need to specify a file name and the actual content
+of the script file. The file does not have to physically exist. It is used by the
+F# compiler to resolve relative references (e.g. #r) and to automatically name
+the module including all code in the file.
+
You can also specify additional parameters, such as *.dll references, by passing
+a third argument with compiler options (e.g. "-r:Foo.dll -r:Bar.dll").
+
This operation might take some time, so it is a good idea to use an asynchronous
+variant of the method. It returns two arrays - the first contains F# snippets
+in the source code and the second contains any errors reported by the compiler.
+A single source file can include multiple snippets using the same formatting tags
+as those used on fssnip.net as documented in the
+about page.
Each returned snippet is essentially just a collection of lines and each line
+consists of a sequence of tokens. The following snippet prints basic information
+about the tokens of our sample snippet:
+
// Get the first snippet and obtain list of lines
+let(Snippet(title,lines))=snippets|>Seq.head
+
+// Iterate over all lines and all tokens on each line
+for(Line(_,tokens))inlinesdo
+ fortokenintokensdo
+ matchtokenwith
+ |TokenSpan.Token(kind,code,tip)->
+ printf"%s"code
+
+ tip
+ |>Option.iter(funspans->printfn"%A"spans)
+ |TokenSpan.Omitted_
+ |TokenSpan.Output_
+ |TokenSpan.Error_->()
+
+ printfn""
+
+
The TokenSpan.Token is the most important kind of token. It consists of a kind
+(identifier, keyword, etc.), the original F# code and tool tip information.
+The tool tip is further formatted using a simple document format, but we simply
+print the value using the F# pretty printing, so the result looks as follows:
The Omitted token is generated if you use the special (*[omit:...]*) command.
+The Output token is generated if you use the // [fsi:...] command to format
+output returned by F# interactive. The Error command wraps code that should be
+underlined with a red squiggle if the code contains an error.
Finally, the CodeFormat type also includes a method CodeFormat.FormatHtml that can be used
+to generate nice HTML output from an F# snippet. This is used, for example, on
+F# Snippets. The following example shows how to call it:
+
letprefix="fst"
+lethtml=CodeFormat.FormatHtml(snippets,prefix)
+
+// Print all snippets, in case there is more of them
+forsnipinhtml.Snippetsdo
+ printfn"%s"snip.Content
+
+// Print HTML code that is generated for ToolTips
+printfn"%s"html.ToolTip
+
+
If the input contains multiple snippets separated using the //[snippet:...] comment, e.g.:
+
+1:
+2:
+3:
+4:
+5:
+6:
+7:
+
+
+
// [snippet: First sample]
+printf"The answer is: %A"42
+// [/snippet]
+// [snippet: Second sample]
+printf"Hello world!"
+// [/snippet]
+
+
+
+
+
then the formatter returns multiple HTML blocks. However, the generated tool tips
+are shared by all snippets (to save space) and so they are returned separately.
val ParseAndCheckSource: file: string * source: string * options: string option * defines: string option * onError: (string -> unit) -> Snippet array * SourceError array <summary>
+ Parse, check and annotate the source code specified by 'source', assuming that it
+ is located in a specified 'file'. Optional arguments can be used
+ to give compiler command line options and preprocessor definitions
+</summary>
+
union case Option.None: Option<'T>
+
val ignore: value: 'T -> unit
+
Multiple items union case Snippet.Snippet: title: string * lines: Line list -> Snippet
-------------------- type Snippet = | Snippet of title: string * lines: Line list <summary>
+ An F# snippet consists of a snippet title and a list of lines
+</summary>
+
val title: string
+
val lines: Line list
+
module Seq
+
+from Microsoft.FSharp.Collections
+
val head: source: 'T seq -> 'T
+
Multiple items union case Line.Line: originalLine: string * tokenSpans: TokenSpans -> Line
-------------------- type Line = | Line of originalLine: string * tokenSpans: TokenSpans <summary>
+ Represents a line of source code as a list of TokenSpan values. This is
+ a single case discriminated union with Line constructor.
+</summary>
+
val tokens: TokenSpans
+
val token: TokenSpan
+
type TokenSpan =
+ | Token of kind: TokenKind * body: string * tip: ToolTipSpans option
+ | Error of kind: ErrorKind * message: string * body: TokenSpans
+ | Omitted of body: string * hidden: string
+ | Output of string <summary>
+ A token in a parsed F# code snippet. Aside from standard tokens reported from
+ the compiler (Token), this also includes Error (wrapping the underlined
+ tokens), Omitted for the special [omit:...] tags and Output for the special [output:...] tag
+</summary>
+
union case TokenSpan.Token: kind: TokenKind * body: string * tip: ToolTipSpans option -> TokenSpan
+
val kind: TokenKind
+
val code: string
+
val tip: ToolTipSpans option
+
val printf: format: Printf.TextWriterFormat<'T> -> 'T
+
module Option
+
+from Microsoft.FSharp.Core
+
val iter: action: ('T -> unit) -> option: 'T option -> unit
+
val spans: ToolTipSpans
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
union case TokenSpan.Omitted: body: string * hidden: string -> TokenSpan
+
union case TokenSpan.Output: string -> TokenSpan
+
union case TokenSpan.Error: kind: ErrorKind * message: string * body: TokenSpans -> TokenSpan
+
Multiple items type LiteralAttribute =
+ inherit Attribute
+ new: unit -> LiteralAttribute
-------------------- new: unit -> LiteralAttribute
+
val prefix: string
+
val html: FormattedContent
+
type CodeFormat =
+ static member FormatFsx: snippets: Snippet seq -> FormattedContent
+ static member FormatHtml: snippets: Snippet array * prefix: string * ?openTag: string * ?closeTag: string * ?lineNumbers: bool * ?openLinesTag: string * ?closeLinesTag: string * ?addErrors: bool * ?tokenKindToCss: (TokenKind -> string) -> FormattedContent
+ static member FormatLatex: snippets: Snippet array * ?openTag: string * ?closeTag: string * ?lineNumbers: bool -> FormattedContent <summary>
+ Exposes functionality of the F# code formatter with a nice interface
+</summary>
property FormattedContent.Snippets: FormattedSnippet array with get <summary>
+ Returns the processed snippets as an array
+</summary>
+
property FormattedSnippet.Content: string with get <summary>
+ Returns the formatted content code for the snipet
+</summary>
+
property FormattedContent.ToolTip: string with get <summary>
+ Returns string with ToolTip elements for all the snippets
+</summary>
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/codeformat.ipynb b/codeformat.ipynb
new file mode 100644
index 000000000..7a59bfaf0
--- /dev/null
+++ b/codeformat.ipynb
@@ -0,0 +1,318 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "#r \"nuget: FSharp.Formatting,1.0.0\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=codeformat.ipynb)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//codeformat.fsx)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//codeformat.ipynb)\n",
+ "\n",
+ "# Code formatting\n",
+ "\n",
+ "This page demonstrates how to use `FSharp.Formatting.CodeFormat` to tokenize\n",
+ "F# source code, obtain information about the source code (mainly tooltips\n",
+ "from the type-checker) and how to turn the code into a nicely formatted HTML.\n",
+ "\n",
+ "First, we need to load the assembly and open necessary namespaces:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "open FSharp.Formatting.CodeFormat\n",
+ "open System.Reflection\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "If you want to process multiple snippets, it is a good idea to keep the\n",
+ "formatting agent around if possible. The agent needs to load the F# compiler\n",
+ "(which needs to load various files itself) and so this takes a long time.\n",
+ "\n",
+ "## Processing F# source\n",
+ "\n",
+ "The formatting agent provides a [CodeFormatAgent.ParseAndCheckSource](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-formatting-codeformat-codeformatagent#ParseAndCheckSource) method (together with an asynchronous\n",
+ "version for use from F# and also a version that returns a .NET `Task` for C#).\n",
+ "To call the method, we define a simple F# code as a string:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let source =\n",
+ " \"\"\"\n",
+ " let hello () =\n",
+ " printfn \"Hello world\"\n",
+ " \"\"\"\n",
+ "\n",
+ "let snippets, diagnostics =\n",
+ " CodeFormatter.ParseAndCheckSource(\"C:\\\\snippet.fsx\", source, None, None, ignore)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "When calling the method, you need to specify a file name and the actual content\n",
+ "of the script file. The file does not have to physically exist. It is used by the\n",
+ "F# compiler to resolve relative references (e.g. `#r`) and to automatically name\n",
+ "the module including all code in the file.\n",
+ "\n",
+ "You can also specify additional parameters, such as `*.dll` references, by passing\n",
+ "a third argument with compiler options (e.g. `\"-r:Foo.dll -r:Bar.dll\"`).\n",
+ "\n",
+ "This operation might take some time, so it is a good idea to use an asynchronous\n",
+ "variant of the method. It returns two arrays - the first contains F# snippets\n",
+ "in the source code and the second contains any errors reported by the compiler.\n",
+ "A single source file can include multiple snippets using the same formatting tags\n",
+ "as those used on [fssnip.net](http://www.fssnip.net) as documented in the\n",
+ "[about page](http://www.fssnip.net/pages/About).\n",
+ "\n",
+ "## Working with returned tokens\n",
+ "\n",
+ "Each returned snippet is essentially just a collection of lines and each line\n",
+ "consists of a sequence of tokens. The following snippet prints basic information\n",
+ "about the tokens of our sample snippet:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "// Get the first snippet and obtain list of lines\n",
+ "let (Snippet (title, lines)) = snippets |\u003e Seq.head\n",
+ "\n",
+ "// Iterate over all lines and all tokens on each line\n",
+ "for (Line (_, tokens)) in lines do\n",
+ " for token in tokens do\n",
+ " match token with\n",
+ " | TokenSpan.Token (kind, code, tip) -\u003e\n",
+ " printf \"%s\" code\n",
+ "\n",
+ " tip\n",
+ " |\u003e Option.iter (fun spans -\u003e printfn \"%A\" spans)\n",
+ " | TokenSpan.Omitted _\n",
+ " | TokenSpan.Output _\n",
+ " | TokenSpan.Error _ -\u003e ()\n",
+ "\n",
+ " printfn \"\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The `TokenSpan.Token` is the most important kind of token. It consists of a kind\n",
+ "(identifier, keyword, etc.), the original F# code and tool tip information.\n",
+ "The tool tip is further formatted using a simple document format, but we simply\n",
+ "print the value using the F# pretty printing, so the result looks as follows:\n",
+ "\n",
+ " let hello[Literal \"val hello : unit -\u003e unit\"; ...] () =\n",
+ " printfn[Literal \"val printfn : TextWriterFormat\u003c\u0027T\u003e -\u003e \u0027T\"; ...] \"Hello world\"\n",
+ "\n",
+ "The `Omitted` token is generated if you use the special `(*[omit:...]*)` command.\n",
+ "The `Output` token is generated if you use the `// [fsi:...]` command to format\n",
+ "output returned by F# interactive. The `Error` command wraps code that should be\n",
+ "underlined with a red squiggle if the code contains an error.\n",
+ "\n",
+ "## Generating HTML output\n",
+ "\n",
+ "Finally, the `CodeFormat` type also includes a method [CodeFormat.FormatHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatHtml) that can be used\n",
+ "to generate nice HTML output from an F# snippet. This is used, for example, on\n",
+ "[F# Snippets](http://www.fssnip.net). The following example shows how to call it:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let prefix = \"fst\"\n",
+ "let html = CodeFormat.FormatHtml(snippets, prefix)\n",
+ "\n",
+ "// Print all snippets, in case there is more of them\n",
+ "for snip in html.Snippets do\n",
+ " printfn \"%s\" snip.Content\n",
+ "\n",
+ "// Print HTML code that is generated for ToolTips\n",
+ "printfn \"%s\" html.ToolTip\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "If the input contains multiple snippets separated using the `//[snippet:...]` comment, e.g.:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "\u003ctable class=\"pre\"\u003e\u003ctr\u003e\u003ctd class=\"lines\"\u003e\u003cpre class=\"fssnip\"\u003e\n",
+ "\u003cspan class=\"l\"\u003e1: \u003c/span\u003e\n",
+ "\u003cspan class=\"l\"\u003e2: \u003c/span\u003e\n",
+ "\u003cspan class=\"l\"\u003e3: \u003c/span\u003e\n",
+ "\u003cspan class=\"l\"\u003e4: \u003c/span\u003e\n",
+ "\u003cspan class=\"l\"\u003e5: \u003c/span\u003e\n",
+ "\u003cspan class=\"l\"\u003e6: \u003c/span\u003e\n",
+ "\u003cspan class=\"l\"\u003e7: \u003c/span\u003e\n",
+ "\u003c/pre\u003e\n",
+ "\u003c/td\u003e\n",
+ "\u003ctd class=\"snippet\"\u003e\u003cpre class=\"fssnip\"\u003e\u003cspan class=\"c\"\u003e// [snippet: First sample]\u003c/span\u003e\n",
+ "\u003cspan class=\"i\"\u003eprintf\u003c/span\u003e \u003cspan class=\"s\"\u003e\"The answer is: %A\"\u003c/span\u003e \u003cspan class=\"n\"\u003e42\u003c/span\u003e\n",
+ "\u003cspan class=\"c\"\u003e// [/snippet]\u003c/span\u003e\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "\u003cspan class=\"c\"\u003e// [snippet: Second sample]\u003c/span\u003e\n",
+ "\u003cspan class=\"i\"\u003eprintf\u003c/span\u003e \u003cspan class=\"s\"\u003e\"Hello world!\"\u003c/span\u003e\n",
+ "\u003cspan class=\"c\"\u003e// [/snippet]\u003c/span\u003e\n",
+ "\u003c/pre\u003e\n",
+ "\u003c/td\u003e\n",
+ "\u003c/tr\u003e\n",
+ "\u003c/table\u003e\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "then the formatter returns multiple HTML blocks. However, the generated tool tips\n",
+ "are shared by all snippets (to save space) and so they are returned separately.\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/codeformat.md b/codeformat.md
new file mode 100644
index 000000000..718c6262f
--- /dev/null
+++ b/codeformat.md
@@ -0,0 +1,139 @@
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=codeformat.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//codeformat.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//codeformat.ipynb)
+
+# Code formatting
+
+This page demonstrates how to use `FSharp.Formatting.CodeFormat` to tokenize
+F# source code, obtain information about the source code (mainly tooltips
+from the type-checker) and how to turn the code into a nicely formatted HTML.
+
+First, we need to load the assembly and open necessary namespaces:
+
+```fsharp
+open FSharp.Formatting.CodeFormat
+open System.Reflection
+```
+
+If you want to process multiple snippets, it is a good idea to keep the
+formatting agent around if possible. The agent needs to load the F# compiler
+(which needs to load various files itself) and so this takes a long time.
+
+## Processing F# source
+
+The formatting agent provides a [CodeFormatAgent.ParseAndCheckSource](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-formatting-codeformat-codeformatagent#ParseAndCheckSource) method (together with an asynchronous
+version for use from F# and also a version that returns a .NET `Task` for C#).
+To call the method, we define a simple F# code as a string:
+
+```fsharp
+let source =
+ """
+ let hello () =
+ printfn "Hello world"
+ """
+
+let snippets, diagnostics =
+ CodeFormatter.ParseAndCheckSource("C:\\snippet.fsx", source, None, None, ignore)
+```
+
+When calling the method, you need to specify a file name and the actual content
+of the script file. The file does not have to physically exist. It is used by the
+F# compiler to resolve relative references (e.g. `#r`) and to automatically name
+the module including all code in the file.
+
+You can also specify additional parameters, such as `*.dll` references, by passing
+a third argument with compiler options (e.g. `"-r:Foo.dll -r:Bar.dll"`).
+
+This operation might take some time, so it is a good idea to use an asynchronous
+variant of the method. It returns two arrays - the first contains F# snippets
+in the source code and the second contains any errors reported by the compiler.
+A single source file can include multiple snippets using the same formatting tags
+as those used on [fssnip.net](http://www.fssnip.net) as documented in the
+[about page](http://www.fssnip.net/pages/About).
+
+## Working with returned tokens
+
+Each returned snippet is essentially just a collection of lines and each line
+consists of a sequence of tokens. The following snippet prints basic information
+about the tokens of our sample snippet:
+
+```fsharp
+// Get the first snippet and obtain list of lines
+let (Snippet (title, lines)) = snippets |> Seq.head
+
+// Iterate over all lines and all tokens on each line
+for (Line (_, tokens)) in lines do
+ for token in tokens do
+ match token with
+ | TokenSpan.Token (kind, code, tip) ->
+ printf "%s" code
+
+ tip
+ |> Option.iter (fun spans -> printfn "%A" spans)
+ | TokenSpan.Omitted _
+ | TokenSpan.Output _
+ | TokenSpan.Error _ -> ()
+
+ printfn ""
+```
+
+The `TokenSpan.Token` is the most important kind of token. It consists of a kind
+(identifier, keyword, etc.), the original F# code and tool tip information.
+The tool tip is further formatted using a simple document format, but we simply
+print the value using the F# pretty printing, so the result looks as follows:
+
+```fsharp
+let hello[Literal "val hello : unit -> unit"; ...] () =
+ printfn[Literal "val printfn : TextWriterFormat<'T> -> 'T"; ...] "Hello world"
+
+```
+
+The `Omitted` token is generated if you use the special `(*[omit:...]*)` command.
+The `Output` token is generated if you use the `// [fsi:...]` command to format
+output returned by F# interactive. The `Error` command wraps code that should be
+underlined with a red squiggle if the code contains an error.
+
+## Generating HTML output
+
+Finally, the `CodeFormat` type also includes a method [CodeFormat.FormatHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatHtml) that can be used
+to generate nice HTML output from an F# snippet. This is used, for example, on
+[F# Snippets](http://www.fssnip.net). The following example shows how to call it:
+
+```fsharp
+let prefix = "fst"
+let html = CodeFormat.FormatHtml(snippets, prefix)
+
+// Print all snippets, in case there is more of them
+for snip in html.Snippets do
+ printfn "%s" snip.Content
+
+// Print HTML code that is generated for ToolTips
+printfn "%s" html.ToolTip
+```
+
+If the input contains multiple snippets separated using the `//[snippet:...]` comment, e.g.:
+
+
+1:
+2:
+3:
+4:
+5:
+6:
+7:
+
+
+
// [snippet: First sample]
+printf"The answer is: %A"42
+// [/snippet]
+// [snippet: Second sample]
+printf"Hello world!"
+// [/snippet]
+
+
+
+
+then the formatter returns multiple HTML blocks. However, the generated tool tips
+are shared by all snippets (to save space) and so they are returned separately.
+
+
diff --git a/codeformat.tex b/codeformat.tex
new file mode 100644
index 000000000..59d4bf6a0
--- /dev/null
+++ b/codeformat.tex
@@ -0,0 +1,228 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+
+
+\href{https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=codeformat.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-binder.svg}
+\caption{Binder}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//codeformat.fsx}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-script.svg}
+\caption{Script}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//codeformat.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-notebook.svg}
+\caption{Notebook}
+\end{figure}
+}
+\section*{Code formatting}
+
+
+
+This page demonstrates how to use \texttt{FSharp.Formatting.CodeFormat} to tokenize
+F\# source code, obtain information about the source code (mainly tooltips
+from the type-checker) and how to turn the code into a nicely formatted HTML.
+
+
+First, we need to load the assembly and open necessary namespaces:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{CodeFormat}
+\kwd{open} \id{System}{.}\id{Reflection}
+
+\end{lstlisting}
+
+
+
+If you want to process multiple snippets, it is a good idea to keep the
+formatting agent around if possible. The agent needs to load the F\# compiler
+(which needs to load various files itself) and so this takes a long time.
+\subsection*{Processing F\# source}
+
+
+
+The formatting agent provides a \href{https://fsharp.github.io/fsharp-core-docs/reference/fsharp-formatting-codeformat-codeformatagent\#ParseAndCheckSource}{CodeFormatAgent.ParseAndCheckSource} method (together with an asynchronous
+version for use from F\# and also a version that returns a .NET \texttt{Task} for C\#).
+To call the method, we define a simple F\# code as a string:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{source} \ops{=}
+ \str{"""}
+\str{ let hello () =}
+\str{ printfn "Hello world"}
+\str{ """}
+
+\kwd{let} \id{snippets}{,} \id{diagnostics} \ops{=}
+ \ltyp{CodeFormatter}{.}\id{ParseAndCheckSource}{(}\str{"C:{\textbackslash}{\textbackslash}snippet.fsx"}{,} \id{source}{,} {None}{,} {None}{,} \lfun{ignore}{)}
+
+\end{lstlisting}
+
+
+
+When calling the method, you need to specify a file name and the actual content
+of the script file. The file does not have to physically exist. It is used by the
+F\# compiler to resolve relative references (e.g. \texttt{\#r}) and to automatically name
+the module including all code in the file.
+
+
+You can also specify additional parameters, such as \texttt{*.dll} references, by passing
+a third argument with compiler options (e.g. \texttt{"-r:Foo.dll -r:Bar.dll"}).
+
+
+This operation might take some time, so it is a good idea to use an asynchronous
+variant of the method. It returns two arrays - the first contains F\# snippets
+in the source code and the second contains any errors reported by the compiler.
+A single source file can include multiple snippets using the same formatting tags
+as those used on \href{http://www.fssnip.net}{fssnip.net} as documented in the
+\href{http://www.fssnip.net/pages/About}{about page}.
+\subsection*{Working with returned tokens}
+
+
+
+Each returned snippet is essentially just a collection of lines and each line
+consists of a sequence of tokens. The following snippet prints basic information
+about the tokens of our sample snippet:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{// Get the first snippet and obtain list of lines}
+\kwd{let} {(}{Snippet} {(}\id{title}{,} \id{lines}{)}{)} \ops{=} \id{snippets} \ops{|>} \ltyp{Seq}{.}\id{head}
+
+\com{// Iterate over all lines and all tokens on each line}
+\kwd{for} {(}{Line} {(}\id{\_}{,} \lfun{tokens}{)}{)} \kwd{in} \id{lines} \kwd{do}
+ \kwd{for} \lfun{token} \kwd{in} \lfun{tokens} \kwd{do}
+ \kwd{match} \lfun{token} \kwd{with}
+ {|} \ltyp{TokenSpan}{.}\id{Token} {(}\lfun{kind}{,} \lfun{code}{,} \lfun{tip}{)} \kwd{->}
+ \lfun{printf} \str{"}\lprf{\%s}\str{"} \lfun{code}
+
+ \lfun{tip}
+ \ops{|>} \ltyp{Option}{.}\id{iter} {(}\kwd{fun} \lfun{spans} \kwd{->} \lfun{printfn} \str{"}\lprf{\%A}\str{"} \lfun{spans}{)}
+ {|} \ltyp{TokenSpan}{.}\id{Omitted} \id{\_}
+ {|} \ltyp{TokenSpan}{.}\id{Output} \id{\_}
+ {|} \ltyp{TokenSpan}{.}\id{Error} \id{\_} \kwd{->} {(}{)}
+
+ \lfun{printfn} \str{""}
+
+\end{lstlisting}
+
+
+
+The \texttt{TokenSpan.Token} is the most important kind of token. It consists of a kind
+(identifier, keyword, etc.), the original F\# code and tool tip information.
+The tool tip is further formatted using a simple document format, but we simply
+print the value using the F\# pretty printing, so the result looks as follows:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{hello}{[}\id{Literal} \str{"val hello : unit -> unit"}{;} \ops{..}{.}{]} {(}{)} \ops{=}
+ \id{printfn}{[}\id{Literal} \str{"val printfn : TextWriterFormat<'T> -> 'T"}{;} \ops{..}{.}{]} \str{"Hello world"}
+
+
+\end{lstlisting}
+
+
+
+The \texttt{Omitted} token is generated if you use the special \texttt{(*[omit:...]*)} command.
+The \texttt{Output} token is generated if you use the \texttt{// [fsi:...]} command to format
+output returned by F\# interactive. The \texttt{Error} command wraps code that should be
+underlined with a red squiggle if the code contains an error.
+\subsection*{Generating HTML output}
+
+
+
+Finally, the \texttt{CodeFormat} type also includes a method \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html\#FormatHtml}{CodeFormat.FormatHtml} that can be used
+to generate nice HTML output from an F\# snippet. This is used, for example, on
+\href{http://www.fssnip.net}{F\# Snippets}. The following example shows how to call it:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{prefix} \ops{=} \str{"fst"}
+\kwd{let} \id{html} \ops{=} \ltyp{CodeFormat}{.}\id{FormatHtml}{(}\id{snippets}{,} \id{prefix}{)}
+
+\com{// Print all snippets, in case there is more of them}
+\kwd{for} \lfun{snip} \kwd{in} \id{html}{.}\id{Snippets} \kwd{do}
+ \lfun{printfn} \str{"}\lprf{\%s}\str{"} \lfun{snip}{.}\id{Content}
+
+\com{// Print HTML code that is generated for ToolTips}
+\lfun{printfn} \str{"}\lprf{\%s}\str{"} \id{html}{.}\id{ToolTip}
+
+\end{lstlisting}
+
+
+
+If the input contains multiple snippets separated using the \texttt{//[snippet:...]} comment, e.g.:
+
+1:
+2:
+3:
+4:
+5:
+6:
+7:
+
+
+
// [snippet: First sample]
+printf"The answer is: %A"42
+// [/snippet]
+// [snippet: Second sample]
+printf"Hello world!"
+// [/snippet]
+
+
+
+
+
+
+then the formatter returns multiple HTML blocks. However, the generated tool tips
+are shared by all snippets (to save space) and so they are returned separately.
+
+
+\end{document}
\ No newline at end of file
diff --git a/commandline.fsx b/commandline.fsx
new file mode 100644
index 000000000..c15a86b22
--- /dev/null
+++ b/commandline.fsx
@@ -0,0 +1,112 @@
+(**
+# Command line
+
+To use F# Formatting tools via the command line, you can use the `fsdocs` dotnet tool.
+
+ [lang=text]
+ dotnet tool install fsdocs-tool
+ dotnet fsdocs [command] [options]
+
+## The build command
+
+This command processes a `docs` directory and generates API docs for projects in the solution according to the
+rules of [API doc generation](apidocs.html). The input accepted is described in [content](content.html).
+
+ [lang=text]
+ fsdocs build
+
+The command line options accepted are:
+
+Command Line Option | Description
+:--- | :---
+`--input` | Input directory of content (default: `docs`)
+`--projects` | Project files to build API docs for outputs, defaults to all packable projects
+`--output` | Output Directory (default 'output' for 'build' and 'tmp/watch' for 'watch')
+`--noapidocs` | Disable generation of API docs
+`--ignoreprojects` | Disable project cracking
+`--eval` | Evaluate F# fragments in scripts
+`--saveimages` | Save images referenced in docs
+`--nolinenumbers` | Don't add line numbers, default is to add line number.
+`--parameters` | Additional substitution parameters for templates
+`--nonpublic` | The tool will also generate documentation for non-public members
+`--nodefaultcontent` | Do not copy default content styles, javascript or use default templates
+`--clean` | Clean the output directory
+`--help` | Display this help screen
+`--version` | Display version information
+`--properties` | Provide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4
+`--fscoptions` | Additional arguments passed down as `otherflags` to the F# compiler when the API is being generated. Note that these arguments are trimmed, this is to overcome [a limitation in the command line argument processing](https://github.com/commandlineparser/commandline/issues/58). A typical use-case would be to pass an addition assembly reference. Example `--fscoptions " -r:MyAssembly.dll"`
+`--strict` | Fail if docs are missing or can't be generated
+
+
+The following command line options are also accepted but it is instead recommended you use
+settings in your .fsproj project files:
+
+Command Line Option | Description
+:--- | :---
+`--sourcefolder` | Source folder at time of component build (``)
+`--sourcerepo` | Source repository for github links (``)
+`--mdcomments` | Assume comments in F# code are markdown (``)
+
+
+The command will report on any `.fsproj` files that it finds, telling you if it decides to skip a particular file and why.
+
+For example, a project will be skipped if:
+
+* The project name contains ".Tests" or "test" (because it looks like a test project)
+
+
+* The project does not contain
+
+
+ ```
+ true
+ ```
+
+
+## The watch command
+
+This command does the same as `fsdocs build` but in "watch" mode, waiting for changes. Only the files in the input
+directory (e.g. `docs`) are watched. A browser will be launched automatically (unless `--nolaunch` is specified).
+
+You will need to ensure that the input directory exists, and contains at least `index.md`, otherwise the browser will
+report an error (e.g. "Problem loading...", "Connection was reset").
+
+ [lang=text]
+ fsdocs watch
+
+Restarting may be necesssary on changes to project files. The same parameters are accepted, plus these:
+
+Command Line Option | Description
+:--- | :---
+`--noserver` | Do not serve content when watching.
+`--nolaunch` | Do not launch a browser window.
+`--open` | URL extension to launch [http://localhost:/%s.](http://localhost:/%s.)
+`--port` | Port to serve content for [http://localhost](http://localhost) serving.
+
+
+## Searchable docs
+
+When using the command-line tool a [Fuse](https://www.fusejs.io/) search index is automatically generated in `index.json`.
+A search box is included in the default template via an [HTML Dialog element](https://developer.mozilla.org/docs/Web/HTML/Element/dialog).
+To add search to your own `_template.html`:
+
+* include an HTML element with id `search-btn`
+
+* include a `dialog` element
+
+* include `fsdocs-search.js` script
+
+```html
+
+
+
+```
+
+*)
+
diff --git a/commandline.html b/commandline.html
new file mode 100644
index 000000000..63292cd1a
--- /dev/null
+++ b/commandline.html
@@ -0,0 +1,518 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Command line
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This command processes a docs directory and generates API docs for projects in the solution according to the
+rules of API doc generation. The input accepted is described in content.
+
fsdocs build
+
+
The command line options accepted are:
+
+
+
+
Command Line Option
+
Description
+
+
+
+
+
--input
+
Input directory of content (default: docs)
+
+
+
--projects
+
Project files to build API docs for outputs, defaults to all packable projects
+
+
+
--output
+
Output Directory (default 'output' for 'build' and 'tmp/watch' for 'watch')
+
+
+
--noapidocs
+
Disable generation of API docs
+
+
+
--ignoreprojects
+
Disable project cracking
+
+
+
--eval
+
Evaluate F# fragments in scripts
+
+
+
--saveimages
+
Save images referenced in docs
+
+
+
--nolinenumbers
+
Don't add line numbers, default is to add line number.
+
+
+
--parameters
+
Additional substitution parameters for templates
+
+
+
--nonpublic
+
The tool will also generate documentation for non-public members
+
+
+
--nodefaultcontent
+
Do not copy default content styles, javascript or use default templates
+
+
+
--clean
+
Clean the output directory
+
+
+
--help
+
Display this help screen
+
+
+
--version
+
Display version information
+
+
+
--properties
+
Provide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4
+
+
+
--fscoptions
+
Additional arguments passed down as otherflags to the F# compiler when the API is being generated. Note that these arguments are trimmed, this is to overcome a limitation in the command line argument processing. A typical use-case would be to pass an addition assembly reference. Example --fscoptions " -r:MyAssembly.dll"
+
+
+
--strict
+
Fail if docs are missing or can't be generated
+
+
+
+
+
The following command line options are also accepted but it is instead recommended you use
+settings in your .fsproj project files:
+
+
+
+
Command Line Option
+
Description
+
+
+
+
+
--sourcefolder
+
Source folder at time of component build (<FsDocsSourceFolder>)
+
+
+
--sourcerepo
+
Source repository for github links (<FsDocsSourceRepository>)
+
+
+
--mdcomments
+
Assume comments in F# code are markdown (<UsesMarkdownComments>)
+
+
+
+
+
The command will report on any .fsproj files that it finds, telling you if it decides to skip a particular file and why.
+
For example, a project will be skipped if:
+
+
The project name contains ".Tests" or "test" (because it looks like a test project)
This command does the same as fsdocs build but in "watch" mode, waiting for changes. Only the files in the input
+directory (e.g. docs) are watched. A browser will be launched automatically (unless --nolaunch is specified).
+
You will need to ensure that the input directory exists, and contains at least index.md, otherwise the browser will
+report an error (e.g. "Problem loading...", "Connection was reset").
+
fsdocs watch
+
+
Restarting may be necesssary on changes to project files. The same parameters are accepted, plus these:
When using the command-line tool a Fuse search index is automatically generated in index.json.
+A search box is included in the default template via an HTML Dialog element.
+To add search to your own _template.html:
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/commandline.ipynb b/commandline.ipynb
new file mode 100644
index 000000000..1b00cf2df
--- /dev/null
+++ b/commandline.ipynb
@@ -0,0 +1,149 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Command line\n",
+ "\n",
+ "To use F# Formatting tools via the command line, you can use the `fsdocs` dotnet tool.\n",
+ "\n",
+ " [lang=text]\n",
+ " dotnet tool install fsdocs-tool\n",
+ " dotnet fsdocs [command] [options]\n",
+ "\n",
+ "## The build command\n",
+ "\n",
+ "This command processes a `docs` directory and generates API docs for projects in the solution according to the\n",
+ "rules of [API doc generation](apidocs.html). The input accepted is described in [content](content.html).\n",
+ "\n",
+ " [lang=text]\n",
+ " fsdocs build\n",
+ "\n",
+ "The command line options accepted are:\n",
+ "\n",
+ "Command Line Option | Description\n",
+ ":--- | :---\n",
+ "`--input` | Input directory of content (default: `docs`)\n",
+ "`--projects` | Project files to build API docs for outputs, defaults to all packable projects\n",
+ "`--output` | Output Directory (default \u0027output\u0027 for \u0027build\u0027 and \u0027tmp/watch\u0027 for \u0027watch\u0027)\n",
+ "`--noapidocs` | Disable generation of API docs\n",
+ "`--ignoreprojects` | Disable project cracking\n",
+ "`--eval` | Evaluate F# fragments in scripts\n",
+ "`--saveimages` | Save images referenced in docs\n",
+ "`--nolinenumbers` | Don\u0027t add line numbers, default is to add line number.\n",
+ "`--parameters` | Additional substitution parameters for templates\n",
+ "`--nonpublic` | The tool will also generate documentation for non-public members\n",
+ "`--nodefaultcontent` | Do not copy default content styles, javascript or use default templates\n",
+ "`--clean` | Clean the output directory\n",
+ "`--help` | Display this help screen\n",
+ "`--version` | Display version information\n",
+ "`--properties` | Provide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4\n",
+ "`--fscoptions` | Additional arguments passed down as `otherflags` to the F# compiler when the API is being generated.\u003cbr/\u003eNote that these arguments are trimmed, this is to overcome [a limitation in the command line argument processing](https://github.com/commandlineparser/commandline/issues/58).\u003cbr/\u003eA typical use-case would be to pass an addition assembly reference.\u003cbr/\u003eExample `--fscoptions \" -r:MyAssembly.dll\"`\n",
+ "`--strict` | Fail if docs are missing or can\u0027t be generated\n",
+ "\n",
+ "\n",
+ "The following command line options are also accepted but it is instead recommended you use\n",
+ "settings in your .fsproj project files:\n",
+ "\n",
+ "Command Line Option | Description\n",
+ ":--- | :---\n",
+ "`--sourcefolder` | Source folder at time of component build (`\u003cFsDocsSourceFolder\u003e`)\n",
+ "`--sourcerepo` | Source repository for github links (`\u003cFsDocsSourceRepository\u003e`)\n",
+ "`--mdcomments` | Assume comments in F# code are markdown (`\u003cUsesMarkdownComments\u003e`)\n",
+ "\n",
+ "\n",
+ "The command will report on any `.fsproj` files that it finds, telling you if it decides to skip a particular file and why.\n",
+ "\n",
+ "For example, a project will be skipped if:\n",
+ "\n",
+ "* The project name contains \".Tests\" or \"test\" (because it looks like a test project)\n",
+ " \n",
+ "\n",
+ "* The project does not contain\n",
+ " \n",
+ "\n",
+ " ```\n",
+ " \u003cGenerateDocumentationFile\u003etrue\u003c/GenerateDocumentationFile\u003e\n",
+ " ```\n",
+ " \n",
+ "\n",
+ "## The watch command\n",
+ "\n",
+ "This command does the same as `fsdocs build` but in \"watch\" mode, waiting for changes. Only the files in the input\n",
+ "directory (e.g. `docs`) are watched. A browser will be launched automatically (unless `--nolaunch` is specified).\n",
+ "\n",
+ "You will need to ensure that the input directory exists, and contains at least `index.md`, otherwise the browser will\n",
+ "report an error (e.g. \"Problem loading...\", \"Connection was reset\").\n",
+ "\n",
+ " [lang=text]\n",
+ " fsdocs watch\n",
+ "\n",
+ "Restarting may be necesssary on changes to project files. The same parameters are accepted, plus these:\n",
+ "\n",
+ "Command Line Option | Description\n",
+ ":--- | :---\n",
+ "`--noserver` | Do not serve content when watching.\n",
+ "`--nolaunch` | Do not launch a browser window.\n",
+ "`--open` | URL extension to launch [http://localhost:\u003cport\u003e/%s.](http://localhost:\u003cport\u003e/%s.)\n",
+ "`--port` | Port to serve content for [http://localhost](http://localhost) serving.\n",
+ "\n",
+ "\n",
+ "## Searchable docs\n",
+ "\n",
+ "When using the command-line tool a [Fuse](https://www.fusejs.io/) search index is automatically generated in `index.json`.\n",
+ "A search box is included in the default template via an [HTML Dialog element](https://developer.mozilla.org/docs/Web/HTML/Element/dialog).\n",
+ "To add search to your own `_template.html`:\n",
+ "\n",
+ "* include an HTML element with id `search-btn`\n",
+ "\n",
+ "* include a `dialog` element\n",
+ "\n",
+ "* include `fsdocs-search.js` script\n",
+ "\n",
+ "```html\n",
+ "\u003cbutton id=\"search-btn\"\u003eOpen search dialog\u003c/button\u003e\n",
+ "\u003cdialog\u003e\n",
+ " \u003cinput type=\"search\" placeholder=\"Search docs\" /\u003e\n",
+ " \u003cdiv class=\"results\"\u003e\n",
+ " \u003cul\u003e\u003c/ul\u003e\n",
+ " \u003cp class=\"empty\"\u003eType something to start searching.\u003c/p\u003e\n",
+ " \u003c/div\u003e\n",
+ "\u003c/dialog\u003e\n",
+ "\u003cscript type=\"module\" src=\"{`{root}}content/fsdocs-search.js\"\u003e\u003c/script\u003e\n",
+ "```\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/commandline.md b/commandline.md
new file mode 100644
index 000000000..e5452f6d9
--- /dev/null
+++ b/commandline.md
@@ -0,0 +1,110 @@
+# Command line
+
+To use F# Formatting tools via the command line, you can use the `fsdocs` dotnet tool.
+
+ [lang=text]
+ dotnet tool install fsdocs-tool
+ dotnet fsdocs [command] [options]
+
+## The build command
+
+This command processes a `docs` directory and generates API docs for projects in the solution according to the
+rules of [API doc generation](apidocs.html). The input accepted is described in [content](content.html).
+
+ [lang=text]
+ fsdocs build
+
+The command line options accepted are:
+
+Command Line Option | Description
+:--- | :---
+`--input` | Input directory of content (default: `docs`)
+`--projects` | Project files to build API docs for outputs, defaults to all packable projects
+`--output` | Output Directory (default 'output' for 'build' and 'tmp/watch' for 'watch')
+`--noapidocs` | Disable generation of API docs
+`--ignoreprojects` | Disable project cracking
+`--eval` | Evaluate F# fragments in scripts
+`--saveimages` | Save images referenced in docs
+`--nolinenumbers` | Don't add line numbers, default is to add line number.
+`--parameters` | Additional substitution parameters for templates
+`--nonpublic` | The tool will also generate documentation for non-public members
+`--nodefaultcontent` | Do not copy default content styles, javascript or use default templates
+`--clean` | Clean the output directory
+`--help` | Display this help screen
+`--version` | Display version information
+`--properties` | Provide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4
+`--fscoptions` | Additional arguments passed down as `otherflags` to the F# compiler when the API is being generated. Note that these arguments are trimmed, this is to overcome [a limitation in the command line argument processing](https://github.com/commandlineparser/commandline/issues/58). A typical use-case would be to pass an addition assembly reference. Example `--fscoptions " -r:MyAssembly.dll"`
+`--strict` | Fail if docs are missing or can't be generated
+
+
+The following command line options are also accepted but it is instead recommended you use
+settings in your .fsproj project files:
+
+Command Line Option | Description
+:--- | :---
+`--sourcefolder` | Source folder at time of component build (``)
+`--sourcerepo` | Source repository for github links (``)
+`--mdcomments` | Assume comments in F# code are markdown (``)
+
+
+The command will report on any `.fsproj` files that it finds, telling you if it decides to skip a particular file and why.
+
+For example, a project will be skipped if:
+
+* The project name contains ".Tests" or "test" (because it looks like a test project)
+
+
+* The project does not contain
+
+
+ ```
+ true
+ ```
+
+
+## The watch command
+
+This command does the same as `fsdocs build` but in "watch" mode, waiting for changes. Only the files in the input
+directory (e.g. `docs`) are watched. A browser will be launched automatically (unless `--nolaunch` is specified).
+
+You will need to ensure that the input directory exists, and contains at least `index.md`, otherwise the browser will
+report an error (e.g. "Problem loading...", "Connection was reset").
+
+ [lang=text]
+ fsdocs watch
+
+Restarting may be necesssary on changes to project files. The same parameters are accepted, plus these:
+
+Command Line Option | Description
+:--- | :---
+`--noserver` | Do not serve content when watching.
+`--nolaunch` | Do not launch a browser window.
+`--open` | URL extension to launch [http://localhost:/%s.](http://localhost:/%s.)
+`--port` | Port to serve content for [http://localhost](http://localhost) serving.
+
+
+## Searchable docs
+
+When using the command-line tool a [Fuse](https://www.fusejs.io/) search index is automatically generated in `index.json`.
+A search box is included in the default template via an [HTML Dialog element](https://developer.mozilla.org/docs/Web/HTML/Element/dialog).
+To add search to your own `_template.html`:
+
+* include an HTML element with id `search-btn`
+
+* include a `dialog` element
+
+* include `fsdocs-search.js` script
+
+```html
+
+
+
+```
+
+
diff --git a/commandline.tex b/commandline.tex
new file mode 100644
index 000000000..948fcd090
--- /dev/null
+++ b/commandline.tex
@@ -0,0 +1,183 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Command line}
+
+
+
+To use F\# Formatting tools via the command line, you can use the \texttt{fsdocs} dotnet tool.
+\begin{lstlisting}
+dotnet tool install fsdocs-tool
+dotnet fsdocs [command] [options]
+
+\end{lstlisting}
+\subsection*{The build command}
+
+
+
+This command processes a \texttt{docs} directory and generates API docs for projects in the solution according to the
+rules of \href{apidocs.html}{API doc generation}. The input accepted is described in \href{content.html}{content}.
+\begin{lstlisting}
+fsdocs build
+
+\end{lstlisting}
+
+
+The command line options accepted are:
+\begin{tabular}{|l|l|}\hline
+\textbf{Command Line Option} & \textbf{Description}\\ \hline\hline
+\texttt{--input} & Input directory of content (default: \texttt{docs})\\ \hline
+\texttt{--projects} & Project files to build API docs for outputs, defaults to all packable projects\\ \hline
+\texttt{--output} & Output Directory (default 'output' for 'build' and 'tmp/watch' for 'watch')\\ \hline
+\texttt{--noapidocs} & Disable generation of API docs\\ \hline
+\texttt{--ignoreprojects} & Disable project cracking\\ \hline
+\texttt{--eval} & Evaluate F\# fragments in scripts\\ \hline
+\texttt{--saveimages} & Save images referenced in docs\\ \hline
+\texttt{--nolinenumbers} & Don't add line numbers, default is to add line number.\\ \hline
+\texttt{--parameters} & Additional substitution parameters for templates\\ \hline
+\texttt{--nonpublic} & The tool will also generate documentation for non-public members\\ \hline
+\texttt{--nodefaultcontent} & Do not copy default content styles, javascript or use default templates\\ \hline
+\texttt{--clean} & Clean the output directory\\ \hline
+\texttt{--help} & Display this help screen\\ \hline
+\texttt{--version} & Display version information\\ \hline
+\texttt{--properties} & Provide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4\\ \hline
+\texttt{--fscoptions} & Additional arguments passed down as \texttt{otherflags} to the F\# compiler when the API is being generated. Note that these arguments are trimmed, this is to overcome \href{https://github.com/commandlineparser/commandline/issues/58}{a limitation in the command line argument processing}. A typical use-case would be to pass an addition assembly reference. Example \texttt{--fscoptions " -r:MyAssembly.dll"}\\ \hline
+\texttt{--strict} & Fail if docs are missing or can't be generated\\ \hline
+\end{tabular}
+
+
+
+The following command line options are also accepted but it is instead recommended you use
+settings in your .fsproj project files:
+\begin{tabular}{|l|l|}\hline
+\textbf{Command Line Option} & \textbf{Description}\\ \hline\hline
+\texttt{--sourcefolder} & Source folder at time of component build (\texttt{})\\ \hline
+\texttt{--sourcerepo} & Source repository for github links (\texttt{})\\ \hline
+\texttt{--mdcomments} & Assume comments in F\# code are markdown (\texttt{})\\ \hline
+\end{tabular}
+
+
+
+The command will report on any \texttt{.fsproj} files that it finds, telling you if it decides to skip a particular file and why.
+
+
+For example, a project will be skipped if:
+\begin{itemize}
+\item
+
+The project name contains ".Tests" or "test" (because it looks like a test project)
+
+\item
+
+The project does not contain
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{<}\id{GenerateDocumentationFile}{>}\kwd{true}\ops{}
+
+
+\end{lstlisting}
+
+
+\end{itemize}
+
+\subsection*{The watch command}
+
+
+
+This command does the same as \texttt{fsdocs build} but in "watch" mode, waiting for changes. Only the files in the input
+directory (e.g. \texttt{docs}) are watched. A browser will be launched automatically (unless \texttt{--nolaunch} is specified).
+
+
+You will need to ensure that the input directory exists, and contains at least \texttt{index.md}, otherwise the browser will
+report an error (e.g. "Problem loading...", "Connection was reset").
+\begin{lstlisting}
+fsdocs watch
+
+\end{lstlisting}
+
+
+Restarting may be necesssary on changes to project files. The same parameters are accepted, plus these:
+\begin{tabular}{|l|l|}\hline
+\textbf{Command Line Option} & \textbf{Description}\\ \hline\hline
+\texttt{--noserver} & Do not serve content when watching.\\ \hline
+\texttt{--nolaunch} & Do not launch a browser window.\\ \hline
+\texttt{--open} & URL extension to launch \href{http://localhost:/\%s.}{http://localhost:/\%s.}\\ \hline
+\texttt{--port} & Port to serve content for \href{http://localhost}{http://localhost} serving.\\ \hline
+\end{tabular}
+
+\subsection*{Searchable docs}
+
+
+
+When using the command-line tool a \href{https://www.fusejs.io/}{Fuse} search index is automatically generated in \texttt{index.json}.
+A search box is included in the default template via an \href{https://developer.mozilla.org/docs/Web/HTML/Element/dialog}{HTML Dialog element}.
+
+To add search to your own \texttt{\_template.html}:
+\begin{itemize}
+\item include an HTML element with id \texttt{search-btn}
+
+\item include a \texttt{dialog} element
+
+\item include \texttt{fsdocs-search.js} script
+
+\end{itemize}
+
+\begin{lstlisting}
+
+
+
+
+\end{lstlisting}
+
+
+\end{document}
\ No newline at end of file
diff --git a/content.fsx b/content.fsx
new file mode 100644
index 000000000..93579ecb8
--- /dev/null
+++ b/content.fsx
@@ -0,0 +1,232 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,1.0.0"
+(**
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=content.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//content.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//content.ipynb)
+
+# Creating Content
+
+The ["fsdocs" tool](commandline.html) allows documentation for a site to be built
+from content in a `docs` directory. The expected structure for a `docs` directory is
+
+ [lang=text]
+ docs/**/*.md -- markdown with embedded code, converted to html and optionally tex/ipynb
+ docs/**/*.fsx -- fsx scripts converted to html and optionally tex/ipynb
+ docs/**/* -- other content, copied over
+ docs/**/_template.html -- optional template, specifies the HTML template for this directory and its contents
+ docs/**/_template.tex -- optionally indicates Latex files should be generated
+ docs/**/_template.ipynb -- optionally indicates F# ipynb files should be generated
+ docs/**/_template.fsx -- optionally indicates F# fsx files should be generated (even from markdown)
+ docs/reference/_template.html -- optionally specifies the default template for reference docs
+
+Processing is by these two commands:
+
+ dotnet fsdocs build
+ dotnet fsdocs watch
+
+The output goes in `output/` by default. Processing is recursive, making this a form of static site generation.
+
+## Literate Scripts and Markdown Content
+
+The input directory may contain [literate scripts](literate.html) and markdown content.
+
+## Other Content
+
+Content that is not `*.fsx` or `*.md` is copied across.
+
+## Default Styling Content
+
+By default additional content such as `fsdocs-search.js`, `fsdocs-tips.js` and `fsdocs-default.css` are included in the
+the `content` directory of the output. This can be suppressed with `--nodefaultcontent` or by having your own
+copy of this content in your `content` directory.
+
+## Ignored Content
+
+Any file or directory beginning with `.` is ignored.
+
+## Front matter
+
+Each content file can have optional frontmatter. This determines the navigation bar title, categorization ordering and meta tags.
+
+For markdown, the format is:
+
+```
+---
+title: Some Title
+category: Some Category
+categoryindex: 2
+index: 3
+description: Some description
+keywords: tag1, tag2, tag3
+---
+```
+For F# scripts the frontmatter is in this form:
+
+ (**
+ ---
+ title: A Literate Script
+ category: Examples
+ categoryindex: 2
+ index: 1
+ description: Some description
+ keywords: tag1, tag2, tag3
+ ---
+ *)
+
+All entries are optional.
+The `categoryindex` determines the ordering of categories.
+The `index` determines the ordering of within each category.
+The `title` is used in the navigation bar instead of any title inferred from the document.
+The `description` is used in `` else `/` followed by `fsdocs-collection-name`
+`fsdocs-collection-name` | Name of .sln, single .fsproj or containing directory
+`fsdocs-content` | Main page content
+`fsdocs-list-of-namespaces` | HTML `
` list of namespaces with links
+`fsdocs-list-of-documents` | HTML `
` list of documents with titles and links
+`fsdocs-page-title` | First h1 heading in literate file. Generated for API docs
+`fsdocs-source` | Original literate script or markdown source
+`fsdocs-source-filename` | Name of original input source, relative to the `docs` root
+`fsdocs-source-basename` | Name of original input source, excluding its extensions, relative to the `docs` root
+`fsdocs-tooltips` | Generated hidden div elements for tooltips
+`fsdocs-watch-script` | The websocket script used in watch mode to trigger hot reload
+`fsdocs-previous-page-link` | A relative link to the previous page based on the frontmatter index data
+`fsdocs-next-page-link` | A relative link to the next page based on the frontmatter index data
+`fsdocs-head-extra` | Additional html content loaded from the `_head.html` file if present in the `--input` folder
+`fsdocs-body-extra` | Additional html content loaded from the `_body.html` file if present in the `--input` folder
+`fsdocs-body-class` | A css class value to help distinguish between `content` and `api-docs`
+`fsdocs-meta-tags` | A set of additional HTML meta tags, present when description and/or keywords are present in the frontmatter
+
+
+The following substitutions are extracted from your project files and may or may not be used by the default
+template:
+
+Substitution name | Value
+:--- | :---
+`fsdocs-copyright` | ``
+`fsdocs-package-project-url` | ``
+`fsdocs-package-license-expression` | ``
+`fsdocs-package-tags` | ``
+`fsdocs-package-version` | ``
+
+
+For the `fsdocs` tool, additional substitutions can be specified using `--parameters`.
+
+## Cross References to API Docs
+
+Markdown content can contain cross-references to API Docs. Use inline
+markdown code snippets of the special form ``cref:T:MyNamespace.MyType`` where `T:MyNamespace.MyType`
+is a method, property or type xml doc sig reference, see [API Docs](apidocs.html).
+This can include any cross-references resolved by fsdocs.
+
+The generated API documentation includes buttons to copy the XML and Markdown forms of API doc references.
+
+For example, within this project,
+
+* the text ``cref:T:FSharp.Formatting.Markdown.MarkdownParagraph`` resolves to the link [MarkdownParagraph](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html)
+
+
+* the text ``cref:T:System.Console`` resolves to the link [Console](https://learn.microsoft.com/dotnet/api/system.console)
+
+
+* the text ``cref:M:System.Console.WriteLine`` resolves to the link [Console.WriteLine](https://learn.microsoft.com/dotnet/api/system.console.writeline)
+
+
+* the text ``cref:M:System.Console.WriteLine(System.String)`` resolves to the link [Console.WriteLine](https://learn.microsoft.com/dotnet/api/system.console.writeline)
+
+
+* the text ```cref:T:FSharp.Control.FSharpAsync`1``` resolves to the link [Async](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync-1)
+
+
+* the text ``cref:T:FSharp.Control.FSharpAsync`` resolves to the link [Async](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync)
+
+
+* the text ```cref:T:FSharp.Core.array`1``` resolves to the link [array](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-array-1)
+
+
+* the text ``cref:T:FSharp.Core.OptionModule`` resolves to the link [Option](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-optionmodule)
+
+
+* the text ````cref:M:FSharp.Collections.ListModule.Append``1```` resolves to the link [ListModule.Append](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-collections-listmodule#Append)
+
+
+> NOTE: These cases act as tests - if the links above do not work, then that indicates a bug or a change in the
+external link. [Please report it](https://github.com/fsprojects/FSharp.Formatting/issues/new).
+>
+
+Determining xmldoc sig references is not simple. The API doc generated pages come with
+buttons to copy out the XmlDoc signature.
+
+## Generating HTML Output
+
+HTML is generated by default. You can also add a `_template.html`. This should contain `{{fsdocs-content}}`, `{{fsdocs-tooltips}}`
+and other placeholders. Substitutions are
+applied to this template.
+If a file `_template.html` exists then is used as the template for HTML generation for that directory and all sub-content.
+
+## Generating LaTeX output
+
+To generate .tex output for each script and markdown file, add a `_template.tex`. Substitutions are
+applied to this template. The file is either empty of contains `{{fsdocs-content}}` as the key where the body
+of the document is placed.
+
+## Generating iPython Notebook output
+
+To generate .ipynb output for each script and markdown file, add a `_template.ipynb`, usually empty. Substitutions are
+applied to this template.
+
+To add a `mybinder` badge to your generated notebook, ensure you have a `Dockerfile` and `NuGet.config`
+in your `docs` directory and use text like this:
+
+ [](https://mybinder.org/v2/gh/fsprojects/FSharp.Formatting/gh-pages?filepath=literate.ipynb)
+
+## Generating Script outputs
+
+To generate .fsx output for each script and markdown file, add a `_template.fsx`, usually empty. Substitutions are
+applied to this template. It is either empty of contains `{{fsdocs-content}}` as the key where the body
+of the script is placed.
+
+*)
+
diff --git a/content.html b/content.html
new file mode 100644
index 000000000..a5b4e11d6
--- /dev/null
+++ b/content.html
@@ -0,0 +1,632 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Creating Content
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The "fsdocs" tool allows documentation for a site to be built
+from content in a docs directory. The expected structure for a docs directory is
+
docs/**/*.md -- markdown with embedded code, converted to html and optionally tex/ipynb
+docs/**/*.fsx -- fsx scripts converted to html and optionally tex/ipynb
+docs/**/* -- other content, copied over
+docs/**/_template.html -- optional template, specifies the HTML template for this directory and its contents
+docs/**/_template.tex -- optionally indicates Latex files should be generated
+docs/**/_template.ipynb -- optionally indicates F# ipynb files should be generated
+docs/**/_template.fsx -- optionally indicates F# fsx files should be generated (even from markdown)
+docs/reference/_template.html -- optionally specifies the default template for reference docs
+
+
Processing is by these two commands:
+
dotnetfsdocsbuild
+dotnetfsdocswatch
+
+
The output goes in output/ by default. Processing is recursive, making this a form of static site generation.
By default additional content such as fsdocs-search.js, fsdocs-tips.js and fsdocs-default.css are included in the
+the content directory of the output. This can be suppressed with --nodefaultcontent or by having your own
+copy of this content in your content directory.
All entries are optional.
+The categoryindex determines the ordering of categories.
+The index determines the ordering of within each category.
+The title is used in the navigation bar instead of any title inferred from the document.
+The description is used in <meta name="description" as part of the {{fsdocs-meta-tags}} substitution.
+The keywords are also used in a meta tag as part of {{fsdocs-meta-tags}}. Separate them using a ,.
Versions of content in other languages should go in two-letter coded sub-directories, e.g.
+
docs/ja/...
+docs/de/...
+
+
These will be elided from the main table-of-contents and search indexes. (Currently no language-specific
+table of contents is built, nor language-specific site search indexes).
Templates are used for HTML (_template.html), LaTeX (_template.tex), Notebooks (_template.ipynb)
+and F# script outputs (_template.fsx).
+
The following substitutions determine the primary (non-styling) content of your site.
+For example {{fsdocs-content}} is replaced with the generated content in each file.
+
Substitutions are applied when generating content from HTML templates, IPYNB templates, FSX templates.
+They are also applied to content apart from Markdown inline code `...`, Markdown LaTeX and
+generated outputs.
+
See Styling for information about template parameters and styling beyond the default template.
+
+
+
+
Substitution name
+
Generated content
+
+
+
+
+
root
+
<PackageProjectUrl> else / followed by fsdocs-collection-name
+
+
+
fsdocs-collection-name
+
Name of .sln, single .fsproj or containing directory
+
+
+
fsdocs-content
+
Main page content
+
+
+
fsdocs-list-of-namespaces
+
HTML <li> list of namespaces with links
+
+
+
fsdocs-list-of-documents
+
HTML <li> list of documents with titles and links
+
+
+
fsdocs-page-title
+
First h1 heading in literate file. Generated for API docs
+
+
+
fsdocs-source
+
Original literate script or markdown source
+
+
+
fsdocs-source-filename
+
Name of original input source, relative to the docs root
+
+
+
fsdocs-source-basename
+
Name of original input source, excluding its extensions, relative to the docs root
+
+
+
fsdocs-tooltips
+
Generated hidden div elements for tooltips
+
+
+
fsdocs-watch-script
+
The websocket script used in watch mode to trigger hot reload
+
+
+
fsdocs-previous-page-link
+
A relative link to the previous page based on the frontmatter index data
+
+
+
fsdocs-next-page-link
+
A relative link to the next page based on the frontmatter index data
+
+
+
fsdocs-head-extra
+
Additional html content loaded from the _head.html file if present in the --input folder
+
+
+
fsdocs-body-extra
+
Additional html content loaded from the _body.html file if present in the --input folder
+
+
+
fsdocs-body-class
+
A css class value to help distinguish between content and api-docs
+
+
+
fsdocs-meta-tags
+
A set of additional HTML meta tags, present when description and/or keywords are present in the frontmatter
+
+
+
+
+
The following substitutions are extracted from your project files and may or may not be used by the default
+template:
+
+
+
+
Substitution name
+
Value
+
+
+
+
+
fsdocs-copyright
+
<Copyright>
+
+
+
fsdocs-package-project-url
+
<PackageProjectUrl>
+
+
+
fsdocs-package-license-expression
+
<PackageLicenseExpression>
+
+
+
fsdocs-package-tags
+
<PackageTags>
+
+
+
fsdocs-package-version
+
<Version>
+
+
+
+
+
For the fsdocs tool, additional substitutions can be specified using --parameters.
Markdown content can contain cross-references to API Docs. Use inline
+markdown code snippets of the special form `cref:T:MyNamespace.MyType` where T:MyNamespace.MyType
+is a method, property or type xml doc sig reference, see API Docs.
+This can include any cross-references resolved by fsdocs.
+
The generated API documentation includes buttons to copy the XML and Markdown forms of API doc references.
+
For example, within this project,
+
+
the text `cref:T:FSharp.Formatting.Markdown.MarkdownParagraph` resolves to the link MarkdownParagraph
+
the text `cref:T:System.Console` resolves to the link Console
+
the text `cref:M:System.Console.WriteLine` resolves to the link Console.WriteLine
+
the text `cref:M:System.Console.WriteLine(System.String)` resolves to the link Console.WriteLine
+
the text ``cref:T:FSharp.Control.FSharpAsync`1`` resolves to the link Async
+
the text `cref:T:FSharp.Control.FSharpAsync` resolves to the link Async
+
the text ``cref:T:FSharp.Core.array`1`` resolves to the link array
+
the text `cref:T:FSharp.Core.OptionModule` resolves to the link Option
+
the text ```cref:M:FSharp.Collections.ListModule.Append``1``` resolves to the link ListModule.Append
+
+
+
NOTE: These cases act as tests - if the links above do not work, then that indicates a bug or a change in the
+external link. Please report it.
+
+
Determining xmldoc sig references is not simple. The API doc generated pages come with
+buttons to copy out the XmlDoc signature.
HTML is generated by default. You can also add a _template.html. This should contain {{fsdocs-content}}, {{fsdocs-tooltips}}
+and other placeholders. Substitutions are
+applied to this template.
+If a file _template.html exists then is used as the template for HTML generation for that directory and all sub-content.
To generate .tex output for each script and markdown file, add a _template.tex. Substitutions are
+applied to this template. The file is either empty of contains {{fsdocs-content}} as the key where the body
+of the document is placed.
To generate .fsx output for each script and markdown file, add a _template.fsx, usually empty. Substitutions are
+applied to this template. It is either empty of contains {{fsdocs-content}} as the key where the body
+of the script is placed.
+
+
union case Option.Some: Value: 'T -> Option<'T>
+
namespace Microsoft.FSharp.Text
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/content.ipynb b/content.ipynb
new file mode 100644
index 000000000..1d4c6bbd7
--- /dev/null
+++ b/content.ipynb
@@ -0,0 +1,290 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "#r \"nuget: FSharp.Formatting,1.0.0\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=content.ipynb)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//content.fsx)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//content.ipynb)\n",
+ "\n",
+ "# Creating Content\n",
+ "\n",
+ "The [\"fsdocs\" tool](commandline.html) allows documentation for a site to be built\n",
+ "from content in a `docs` directory. The expected structure for a `docs` directory is\n",
+ "\n",
+ " [lang=text]\n",
+ " docs/**/*.md -- markdown with embedded code, converted to html and optionally tex/ipynb\n",
+ " docs/**/*.fsx -- fsx scripts converted to html and optionally tex/ipynb\n",
+ " docs/**/* -- other content, copied over\n",
+ " docs/**/_template.html -- optional template, specifies the HTML template for this directory and its contents\n",
+ " docs/**/_template.tex -- optionally indicates Latex files should be generated\n",
+ " docs/**/_template.ipynb -- optionally indicates F# ipynb files should be generated\n",
+ " docs/**/_template.fsx -- optionally indicates F# fsx files should be generated (even from markdown)\n",
+ " docs/reference/_template.html -- optionally specifies the default template for reference docs\n",
+ "\n",
+ "Processing is by these two commands:\n",
+ "\n",
+ " dotnet fsdocs build\n",
+ " dotnet fsdocs watch\n",
+ "\n",
+ "The output goes in `output/` by default. Processing is recursive, making this a form of static site generation.\n",
+ "\n",
+ "## Literate Scripts and Markdown Content\n",
+ "\n",
+ "The input directory may contain [literate scripts](literate.html) and markdown content.\n",
+ "\n",
+ "## Other Content\n",
+ "\n",
+ "Content that is not `*.fsx` or `*.md` is copied across.\n",
+ "\n",
+ "## Default Styling Content\n",
+ "\n",
+ "By default additional content such as `fsdocs-search.js`, `fsdocs-tips.js` and `fsdocs-default.css` are included in the\n",
+ "the `content` directory of the output. This can be suppressed with `--nodefaultcontent` or by having your own\n",
+ "copy of this content in your `content` directory.\n",
+ "\n",
+ "## Ignored Content\n",
+ "\n",
+ "Any file or directory beginning with `.` is ignored.\n",
+ "\n",
+ "## Front matter\n",
+ "\n",
+ "Each content file can have optional frontmatter. This determines the navigation bar title, categorization ordering and meta tags.\n",
+ "\n",
+ "For markdown, the format is:\n",
+ "\n",
+ "```\n",
+ "---\n",
+ "title: Some Title\n",
+ "category: Some Category\n",
+ "categoryindex: 2\n",
+ "index: 3\n",
+ "description: Some description\n",
+ "keywords: tag1, tag2, tag3\n",
+ "---\n",
+ "```\n",
+ "For F# scripts the frontmatter is in this form:\n",
+ "\n",
+ " (**\n",
+ " ---\n",
+ " title: A Literate Script\n",
+ " category: Examples\n",
+ " categoryindex: 2\n",
+ " index: 1\n",
+ " description: Some description\n",
+ " keywords: tag1, tag2, tag3\n",
+ " ---\n",
+ " *)\n",
+ "\n",
+ "All entries are optional.\n",
+ "The `categoryindex` determines the ordering of categories.\n",
+ "The `index` determines the ordering of within each category.\n",
+ "The `title` is used in the navigation bar instead of any title inferred from the document.\n",
+ "The `description` is used in `\u003cmeta name=\"description\"` as part of the `{{fsdocs-meta-tags}}` substitution.\n",
+ "The `keywords` are also used in a meta tag as part of `{{fsdocs-meta-tags}}`. Separate them using a `,`.\n",
+ "\n",
+ "## Link Translation for Inputs\n",
+ "\n",
+ "If an input is used in markdown as a target of a markdown direct link then that is replaced by the output file. For example:\n",
+ "\n",
+ " [Some Text](some-file.md)\n",
+ "\n",
+ "becomes\n",
+ "\n",
+ " [Some Text](some-file.html)\n",
+ "\n",
+ "if `some-file.md` is one of the inputs.\n",
+ "\n",
+ "## Multi-language Content\n",
+ "\n",
+ "Versions of content in other languages should go in two-letter coded sub-directories, e.g.\n",
+ "\n",
+ " docs/ja/...\n",
+ " docs/de/...\n",
+ "\n",
+ "These will be elided from the main table-of-contents and search indexes. (Currently no language-specific\n",
+ "table of contents is built, nor language-specific site search indexes).\n",
+ "\n",
+ "## Templates and Substitutions\n",
+ "\n",
+ "Templates are used for HTML (`_template.html`), LaTeX (`_template.tex`), Notebooks (`_template.ipynb)`\n",
+ "and F# script outputs (`_template.fsx`).\n",
+ "\n",
+ "The following substitutions determine the primary (non-styling) content of your site.\n",
+ "For example `{{fsdocs-content}}` is replaced with the generated content in each file.\n",
+ "\n",
+ "Substitutions are applied when generating content from HTML templates, IPYNB templates, FSX templates.\n",
+ "They are also applied to content apart from Markdown inline code ``...``, Markdown LaTeX and\n",
+ "generated outputs.\n",
+ "\n",
+ "See [Styling](styling.html) for information about template parameters and styling beyond the default template.\n",
+ "\n",
+ "Substitution name | Generated content\n",
+ ":--- | :---\n",
+ "`root` | `\u003cPackageProjectUrl\u003e` else `/` followed by `fsdocs-collection-name`\n",
+ "`fsdocs-collection-name` | Name of .sln, single .fsproj or containing directory\n",
+ "`fsdocs-content` | Main page content\n",
+ "`fsdocs-list-of-namespaces` | HTML `\u003cli\u003e` list of namespaces with links\n",
+ "`fsdocs-list-of-documents` | HTML `\u003cli\u003e` list of documents with titles and links\n",
+ "`fsdocs-page-title` | First h1 heading in literate file. Generated for API docs\n",
+ "`fsdocs-source` | Original literate script or markdown source\n",
+ "`fsdocs-source-filename` | Name of original input source, relative to the `docs` root\n",
+ "`fsdocs-source-basename` | Name of original input source, excluding its extensions, relative to the `docs` root\n",
+ "`fsdocs-tooltips` | Generated hidden div elements for tooltips\n",
+ "`fsdocs-watch-script` | The websocket script used in watch mode to trigger hot reload\n",
+ "`fsdocs-previous-page-link` | A relative link to the previous page based on the frontmatter index data\n",
+ "`fsdocs-next-page-link` | A relative link to the next page based on the frontmatter index data\n",
+ "`fsdocs-head-extra` | Additional html content loaded from the `_head.html` file if present in the `--input` folder\n",
+ "`fsdocs-body-extra` | Additional html content loaded from the `_body.html` file if present in the `--input` folder\n",
+ "`fsdocs-body-class` | A css class value to help distinguish between `content` and `api-docs`\n",
+ "`fsdocs-meta-tags` | A set of additional HTML meta tags, present when description and/or keywords are present in the frontmatter\n",
+ "\n",
+ "\n",
+ "The following substitutions are extracted from your project files and may or may not be used by the default\n",
+ "template:\n",
+ "\n",
+ "Substitution name | Value\n",
+ ":--- | :---\n",
+ "`fsdocs-copyright` | `\u003cCopyright\u003e`\n",
+ "`fsdocs-package-project-url` | `\u003cPackageProjectUrl\u003e`\n",
+ "`fsdocs-package-license-expression` | `\u003cPackageLicenseExpression\u003e`\n",
+ "`fsdocs-package-tags` | `\u003cPackageTags\u003e`\n",
+ "`fsdocs-package-version` | `\u003cVersion\u003e`\n",
+ "\n",
+ "\n",
+ "For the `fsdocs` tool, additional substitutions can be specified using `--parameters`.\n",
+ "\n",
+ "## Cross References to API Docs\n",
+ "\n",
+ "Markdown content can contain cross-references to API Docs. Use inline\n",
+ "markdown code snippets of the special form ``cref:T:MyNamespace.MyType`` where `T:MyNamespace.MyType`\n",
+ "is a method, property or type xml doc sig reference, see [API Docs](apidocs.html).\n",
+ "This can include any cross-references resolved by fsdocs.\n",
+ "\n",
+ "The generated API documentation includes buttons to copy the XML and Markdown forms of API doc references.\n",
+ "\n",
+ "For example, within this project,\n",
+ "\n",
+ "* the text ``cref:T:FSharp.Formatting.Markdown.MarkdownParagraph`` resolves to the link [MarkdownParagraph](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html)\n",
+ " \n",
+ "\n",
+ "* the text ``cref:T:System.Console`` resolves to the link [Console](https://learn.microsoft.com/dotnet/api/system.console)\n",
+ " \n",
+ "\n",
+ "* the text ``cref:M:System.Console.WriteLine`` resolves to the link [Console.WriteLine](https://learn.microsoft.com/dotnet/api/system.console.writeline)\n",
+ " \n",
+ "\n",
+ "* the text ``cref:M:System.Console.WriteLine(System.String)`` resolves to the link [Console.WriteLine](https://learn.microsoft.com/dotnet/api/system.console.writeline)\n",
+ " \n",
+ "\n",
+ "* the text ```cref:T:FSharp.Control.FSharpAsync`1``` resolves to the link [Async](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync-1)\n",
+ " \n",
+ "\n",
+ "* the text ``cref:T:FSharp.Control.FSharpAsync`` resolves to the link [Async](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync)\n",
+ " \n",
+ "\n",
+ "* the text ```cref:T:FSharp.Core.array`1``` resolves to the link [array](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-array-1)\n",
+ " \n",
+ "\n",
+ "* the text ``cref:T:FSharp.Core.OptionModule`` resolves to the link [Option](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-optionmodule)\n",
+ " \n",
+ "\n",
+ "* the text ````cref:M:FSharp.Collections.ListModule.Append``1```` resolves to the link [ListModule.Append](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-collections-listmodule#Append)\n",
+ " \n",
+ "\n",
+ "\u003e NOTE: These cases act as tests - if the links above do not work, then that indicates a bug or a change in the\n",
+ "external link. [Please report it](https://github.com/fsprojects/FSharp.Formatting/issues/new).\n",
+ "\u003e \n",
+ "\n",
+ "Determining xmldoc sig references is not simple. The API doc generated pages come with\n",
+ "buttons to copy out the XmlDoc signature.\n",
+ "\n",
+ "## Generating HTML Output\n",
+ "\n",
+ "HTML is generated by default. You can also add a `_template.html`. This should contain `{{fsdocs-content}}`, `{{fsdocs-tooltips}}`\n",
+ "and other placeholders. Substitutions are\n",
+ "applied to this template.\n",
+ "If a file `_template.html` exists then is used as the template for HTML generation for that directory and all sub-content.\n",
+ "\n",
+ "## Generating LaTeX output\n",
+ "\n",
+ "To generate .tex output for each script and markdown file, add a `_template.tex`. Substitutions are\n",
+ "applied to this template. The file is either empty of contains `{{fsdocs-content}}` as the key where the body\n",
+ "of the document is placed.\n",
+ "\n",
+ "## Generating iPython Notebook output\n",
+ "\n",
+ "To generate .ipynb output for each script and markdown file, add a `_template.ipynb`, usually empty. Substitutions are\n",
+ "applied to this template.\n",
+ "\n",
+ "To add a `mybinder` badge to your generated notebook, ensure you have a `Dockerfile` and `NuGet.config`\n",
+ "in your `docs` directory and use text like this:\n",
+ "\n",
+ " [](https://mybinder.org/v2/gh/fsprojects/FSharp.Formatting/gh-pages?filepath=literate.ipynb)\n",
+ "\n",
+ "## Generating Script outputs\n",
+ "\n",
+ "To generate .fsx output for each script and markdown file, add a `_template.fsx`, usually empty. Substitutions are\n",
+ "applied to this template. It is either empty of contains `{{fsdocs-content}}` as the key where the body\n",
+ "of the script is placed.\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/content.md b/content.md
new file mode 100644
index 000000000..90b2c4cb5
--- /dev/null
+++ b/content.md
@@ -0,0 +1,245 @@
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=content.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//content.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//content.ipynb)
+
+# Creating Content
+
+The ["fsdocs" tool](commandline.html) allows documentation for a site to be built
+from content in a `docs` directory. The expected structure for a `docs` directory is
+
+docs/**/*.md -- markdown with embedded code, converted to html and optionally tex/ipynb
+docs/**/*.fsx -- fsx scripts converted to html and optionally tex/ipynb
+docs/**/* -- other content, copied over
+docs/**/_template.html -- optional template, specifies the HTML template for this directory and its contents
+docs/**/_template.tex -- optionally indicates Latex files should be generated
+docs/**/_template.ipynb -- optionally indicates F# ipynb files should be generated
+docs/**/_template.fsx -- optionally indicates F# fsx files should be generated (even from markdown)
+docs/reference/_template.html -- optionally specifies the default template for reference docs
+
+Processing is by these two commands:
+
+```fsharp
+dotnet fsdocs build
+dotnet fsdocs watch
+
+```
+
+The output goes in `output/` by default. Processing is recursive, making this a form of static site generation.
+
+## Literate Scripts and Markdown Content
+
+The input directory may contain [literate scripts](literate.html) and markdown content.
+
+## Other Content
+
+Content that is not `*.fsx` or `*.md` is copied across.
+
+## Default Styling Content
+
+By default additional content such as `fsdocs-search.js`, `fsdocs-tips.js` and `fsdocs-default.css` are included in the
+the `content` directory of the output. This can be suppressed with `--nodefaultcontent` or by having your own
+copy of this content in your `content` directory.
+
+## Ignored Content
+
+Any file or directory beginning with `.` is ignored.
+
+## Front matter
+
+Each content file can have optional frontmatter. This determines the navigation bar title, categorization ordering and meta tags.
+
+For markdown, the format is:
+
+```fsharp
+---
+title: Some Title
+category: Some Category
+categoryindex: 2
+index: 3
+description: Some description
+keywords: tag1, tag2, tag3
+---
+
+```
+
+For F# scripts the frontmatter is in this form:
+
+```fsharp
+(**
+---
+title: A Literate Script
+category: Examples
+categoryindex: 2
+index: 1
+description: Some description
+keywords: tag1, tag2, tag3
+---
+*)
+
+```
+
+All entries are optional.
+The `categoryindex` determines the ordering of categories.
+The `index` determines the ordering of within each category.
+The `title` is used in the navigation bar instead of any title inferred from the document.
+The `description` is used in `` else `/` followed by `fsdocs-collection-name`
+`fsdocs-collection-name` | Name of .sln, single .fsproj or containing directory
+`fsdocs-content` | Main page content
+`fsdocs-list-of-namespaces` | HTML `
` list of namespaces with links
+`fsdocs-list-of-documents` | HTML `
` list of documents with titles and links
+`fsdocs-page-title` | First h1 heading in literate file. Generated for API docs
+`fsdocs-source` | Original literate script or markdown source
+`fsdocs-source-filename` | Name of original input source, relative to the `docs` root
+`fsdocs-source-basename` | Name of original input source, excluding its extensions, relative to the `docs` root
+`fsdocs-tooltips` | Generated hidden div elements for tooltips
+`fsdocs-watch-script` | The websocket script used in watch mode to trigger hot reload
+`fsdocs-previous-page-link` | A relative link to the previous page based on the frontmatter index data
+`fsdocs-next-page-link` | A relative link to the next page based on the frontmatter index data
+`fsdocs-head-extra` | Additional html content loaded from the `_head.html` file if present in the `--input` folder
+`fsdocs-body-extra` | Additional html content loaded from the `_body.html` file if present in the `--input` folder
+`fsdocs-body-class` | A css class value to help distinguish between `content` and `api-docs`
+`fsdocs-meta-tags` | A set of additional HTML meta tags, present when description and/or keywords are present in the frontmatter
+
+
+The following substitutions are extracted from your project files and may or may not be used by the default
+template:
+
+Substitution name | Value
+:--- | :---
+`fsdocs-copyright` | ``
+`fsdocs-package-project-url` | ``
+`fsdocs-package-license-expression` | ``
+`fsdocs-package-tags` | ``
+`fsdocs-package-version` | ``
+
+
+For the `fsdocs` tool, additional substitutions can be specified using `--parameters`.
+
+## Cross References to API Docs
+
+Markdown content can contain cross-references to API Docs. Use inline
+markdown code snippets of the special form ``cref:T:MyNamespace.MyType`` where `T:MyNamespace.MyType`
+is a method, property or type xml doc sig reference, see [API Docs](apidocs.html).
+This can include any cross-references resolved by fsdocs.
+
+The generated API documentation includes buttons to copy the XML and Markdown forms of API doc references.
+
+For example, within this project,
+
+* the text ``cref:T:FSharp.Formatting.Markdown.MarkdownParagraph`` resolves to the link [MarkdownParagraph](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html)
+
+
+* the text ``cref:T:System.Console`` resolves to the link [Console](https://learn.microsoft.com/dotnet/api/system.console)
+
+
+* the text ``cref:M:System.Console.WriteLine`` resolves to the link [Console.WriteLine](https://learn.microsoft.com/dotnet/api/system.console.writeline)
+
+
+* the text ``cref:M:System.Console.WriteLine(System.String)`` resolves to the link [Console.WriteLine](https://learn.microsoft.com/dotnet/api/system.console.writeline)
+
+
+* the text ```cref:T:FSharp.Control.FSharpAsync`1``` resolves to the link [Async](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync-1)
+
+
+* the text ``cref:T:FSharp.Control.FSharpAsync`` resolves to the link [Async](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync)
+
+
+* the text ```cref:T:FSharp.Core.array`1``` resolves to the link [array](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-array-1)
+
+
+* the text ``cref:T:FSharp.Core.OptionModule`` resolves to the link [Option](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-optionmodule)
+
+
+* the text ````cref:M:FSharp.Collections.ListModule.Append``1```` resolves to the link [ListModule.Append](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-collections-listmodule#Append)
+
+
+> NOTE: These cases act as tests - if the links above do not work, then that indicates a bug or a change in the
+external link. [Please report it](https://github.com/fsprojects/FSharp.Formatting/issues/new).
+>
+
+Determining xmldoc sig references is not simple. The API doc generated pages come with
+buttons to copy out the XmlDoc signature.
+
+## Generating HTML Output
+
+HTML is generated by default. You can also add a `_template.html`. This should contain `{{fsdocs-content}}`, `{{fsdocs-tooltips}}`
+and other placeholders. Substitutions are
+applied to this template.
+If a file `_template.html` exists then is used as the template for HTML generation for that directory and all sub-content.
+
+## Generating LaTeX output
+
+To generate .tex output for each script and markdown file, add a `_template.tex`. Substitutions are
+applied to this template. The file is either empty of contains `{{fsdocs-content}}` as the key where the body
+of the document is placed.
+
+## Generating iPython Notebook output
+
+To generate .ipynb output for each script and markdown file, add a `_template.ipynb`, usually empty. Substitutions are
+applied to this template.
+
+To add a `mybinder` badge to your generated notebook, ensure you have a `Dockerfile` and `NuGet.config`
+in your `docs` directory and use text like this:
+
+```fsharp
+[](https://mybinder.org/v2/gh/fsprojects/FSharp.Formatting/gh-pages?filepath=literate.ipynb)
+
+```
+
+## Generating Script outputs
+
+To generate .fsx output for each script and markdown file, add a `_template.fsx`, usually empty. Substitutions are
+applied to this template. It is either empty of contains `{{fsdocs-content}}` as the key where the body
+of the script is placed.
+
+
diff --git a/content.tex b/content.tex
new file mode 100644
index 000000000..6fa78f4f1
--- /dev/null
+++ b/content.tex
@@ -0,0 +1,375 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+
+
+\href{https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=content.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-binder.svg}
+\caption{Binder}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//content.fsx}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-script.svg}
+\caption{Script}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//content.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-notebook.svg}
+\caption{Notebook}
+\end{figure}
+}
+\section*{Creating Content}
+
+
+
+The \href{commandline.html}{"fsdocs" tool} allows documentation for a site to be built
+from content in a \texttt{docs} directory. The expected structure for a \texttt{docs} directory is
+\begin{lstlisting}
+docs/**/*.md -- markdown with embedded code, converted to html and optionally tex/ipynb
+docs/**/*.fsx -- fsx scripts converted to html and optionally tex/ipynb
+docs/**/* -- other content, copied over
+docs/**/_template.html -- optional template, specifies the HTML template for this directory and its contents
+docs/**/_template.tex -- optionally indicates Latex files should be generated
+docs/**/_template.ipynb -- optionally indicates F# ipynb files should be generated
+docs/**/_template.fsx -- optionally indicates F# fsx files should be generated (even from markdown)
+docs/reference/_template.html -- optionally specifies the default template for reference docs
+
+\end{lstlisting}
+
+
+Processing is by these two commands:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\id{dotnet} \id{fsdocs} \id{build}
+\id{dotnet} \id{fsdocs} \id{watch}
+
+
+\end{lstlisting}
+
+
+
+The output goes in \texttt{output/} by default. Processing is recursive, making this a form of static site generation.
+\subsection*{Literate Scripts and Markdown Content}
+
+
+
+The input directory may contain \href{literate.html}{literate scripts} and markdown content.
+\subsection*{Other Content}
+
+
+
+Content that is not \texttt{*.fsx} or \texttt{*.md} is copied across.
+\subsection*{Default Styling Content}
+
+
+
+By default additional content such as \texttt{fsdocs-search.js}, \texttt{fsdocs-tips.js} and \texttt{fsdocs-default.css} are included in the
+the \texttt{content} directory of the output. This can be suppressed with \texttt{--nodefaultcontent} or by having your own
+copy of this content in your \texttt{content} directory.
+\subsection*{Ignored Content}
+
+
+
+Any file or directory beginning with \texttt{.} is ignored.
+\subsection*{Front matter}
+
+
+
+Each content file can have optional frontmatter. This determines the navigation bar title, categorization ordering and meta tags.
+
+
+For markdown, the format is:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{---}
+\id{title}{:} \id{Some} \id{Title}
+\id{category}{:} \id{Some} \id{Category}
+\id{categoryindex}{:} \num{2}
+\id{index}{:} \num{3}
+\id{description}{:} \id{Some} \id{description}
+\id{keywords}{:} \id{tag1}{,} \id{tag2}{,} \id{tag3}
+\ops{---}
+
+
+\end{lstlisting}
+
+
+
+For F\# scripts the frontmatter is in this form:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{(**}
+\com{---}
+\com{title: A Literate Script}
+\com{category: Examples}
+\com{categoryindex: 2}
+\com{index: 1}
+\com{description: Some description}
+\com{keywords: tag1, tag2, tag3}
+\com{---}
+\com{*)}
+
+
+\end{lstlisting}
+
+
+
+All entries are optional.
+The \texttt{categoryindex} determines the ordering of categories.
+The \texttt{index} determines the ordering of within each category.
+The \texttt{title} is used in the navigation bar instead of any title inferred from the document.
+The \texttt{description} is used in \texttt{} else \texttt{/} followed by \texttt{fsdocs-collection-name}\\ \hline
+\texttt{fsdocs-collection-name} & Name of .sln, single .fsproj or containing directory\\ \hline
+\texttt{fsdocs-content} & Main page content\\ \hline
+\texttt{fsdocs-list-of-namespaces} & HTML \texttt{
} list of namespaces with links\\ \hline
+\texttt{fsdocs-list-of-documents} & HTML \texttt{
+directly into the document.
+
+## F# Formatting as a Library: Specifying the Evaluator and Formatting
+
+If using F# Formatting as a library the embedding of F# output requires specifying an additional parameter to the
+parsing functions discussed in [literate programming documentation](literate.html).
+Assuming you have all the references in place, you can now create an instance of
+[FsiEvaluator](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html) that represents a wrapper for F# interactive and pass it to all the
+functions that parse script files or process script files:
+
+*)
+open FSharp.Formatting.Literate
+open FSharp.Formatting.Literate.Evaluation
+open FSharp.Formatting.Markdown
+
+// Sample literate content
+let content =
+ """
+let a = 10
+(*** include-value:a ***)"""
+
+// Create evaluator and parse script
+let fsi = FsiEvaluator()
+
+let doc = Literate.ParseScriptString(content, fsiEvaluator = fsi)
+
+Literate.ToHtml(doc)
+(**
+When the `fsiEvaluator` parameter is specified, the script is evaluated and so you
+can use additional commands such as `include-value`. When the evaluator is **not** specified,
+it is not created automatically and so the functionality is not available (this way,
+you won't accidentally run unexpected code!)
+
+If you specify the `fsiEvaluator` parameter, but don't want a specific snippet to be evaluated
+(because it might throw an exception, for example), you can use the `(*** do-not-eval ***)`
+command.
+
+The constructor of [FsiEvaluator](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html) takes command line parameters for `fsi.exe` that can
+be used to specify, for example, defined symbols and other attributes for F# Interactive.
+
+You can also subscribe to the `EvaluationFailed` event which is fired whenever the evaluation
+of an expression fails. You can use that to do tests that verify that all off the code in your
+documentation executes without errors.
+
+## F# Formatting as a Library: Custom formatting functions
+
+As mentioned earlier, values are formatted using a simple `"%A"` formatter by default.
+However, you can specify a formatting function that provides a nicer formatting for values
+of certain types. For example, let's say that we would want to format F# lists such as
+`[1; 2; 3]` as HTML ordered lists ``.
+
+This can be done by calling [FsiEvaluator.RegisterTransformation](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#RegisterTransformation) on the `FsiEvaluator` instance:
+
+*)
+// Create evaluator & register simple formatter for lists
+let fsiEvaluator = FsiEvaluator()
+
+fsiEvaluator.RegisterTransformation(fun (o, ty, _executionCount) ->
+ // If the type of value is an F# list, format it nicely
+ if ty.IsGenericType
+ && ty.GetGenericTypeDefinition() = typedefof> then
+ let items =
+ // Get items as objects and create paragraph for each item
+ [ for it in Seq.cast (unbox o) -> [ Paragraph([ Literal(it.ToString(), None) ], None) ] ]
+ // Return option value (success) with ordered list
+ Some [ ListBlock(MarkdownListKind.Ordered, items, None) ]
+ else
+ None)
+(**
+The function is called with two arguments - `o` is the value to be formatted and `ty`
+is the static type of the value (as inferred by the F# compiler). The sample checks
+that the type of the value is a list (containing values of any type) and then it
+casts all values in the list to `obj` (for simplicity). Then we generate Markdown
+blocks representing an ordered list. This means that the code will work for both
+LaTeX and HTML formatting - but if you only need one, you can simply produce HTML and
+embed it in `InlineHtmlBlock`.
+
+To use the new `FsiEvaluator`, we can use the same style as earlier. This time, we format
+a simple list containing strings:
+
+*)
+let listy =
+ """
+### Formatting demo
+let test = ["one";"two";"three"]
+(*** include-value:test ***)"""
+
+let docOl = Literate.ParseScriptString(listy, fsiEvaluator = fsiEvaluator)
+
+Literate.ToHtml(docOl)
+(**
+The resulting HTML formatting of the document contains the snippet that defines `test`,
+followed by a nicely formatted ordered list:
+
+
For literate F# scripts, you may embed the result of running the script as part of the literate output.
+This is a feature of the functions discussed in literate programming and
+it is implemented using the F# Compiler service.
If using F# Formatting as a library the embedding of F# output requires specifying an additional parameter to the
+parsing functions discussed in literate programming documentation.
+Assuming you have all the references in place, you can now create an instance of
+FsiEvaluator that represents a wrapper for F# interactive and pass it to all the
+functions that parse script files or process script files:
When the fsiEvaluator parameter is specified, the script is evaluated and so you
+can use additional commands such as include-value. When the evaluator is not specified,
+it is not created automatically and so the functionality is not available (this way,
+you won't accidentally run unexpected code!)
+
If you specify the fsiEvaluator parameter, but don't want a specific snippet to be evaluated
+(because it might throw an exception, for example), you can use the (*** do-not-eval ***)
+command.
+
The constructor of FsiEvaluator takes command line parameters for fsi.exe that can
+be used to specify, for example, defined symbols and other attributes for F# Interactive.
+
You can also subscribe to the EvaluationFailed event which is fired whenever the evaluation
+of an expression fails. You can use that to do tests that verify that all off the code in your
+documentation executes without errors.
As mentioned earlier, values are formatted using a simple "%A" formatter by default.
+However, you can specify a formatting function that provides a nicer formatting for values
+of certain types. For example, let's say that we would want to format F# lists such as
+[1; 2; 3] as HTML ordered lists <ol>.
// Create evaluator & register simple formatter for lists
+letfsiEvaluator=FsiEvaluator()
+
+fsiEvaluator.RegisterTransformation(fun(o,ty,_executionCount)->
+ // If the type of value is an F# list, format it nicely
+ ifty.IsGenericType
+ &&ty.GetGenericTypeDefinition()=typedefof<list<_>>then
+ letitems=
+ // Get items as objects and create paragraph for each item
+ [foritinSeq.cast<obj>(unboxo)->[Paragraph([Literal(it.ToString(),None)],None)]]
+ // Return option value (success) with ordered list
+ Some[ListBlock(MarkdownListKind.Ordered,items,None)]
+ else
+ None)
+
+
The function is called with two arguments - o is the value to be formatted and ty
+is the static type of the value (as inferred by the F# compiler). The sample checks
+that the type of the value is a list (containing values of any type) and then it
+casts all values in the list to obj (for simplicity). Then we generate Markdown
+blocks representing an ordered list. This means that the code will work for both
+LaTeX and HTML formatting - but if you only need one, you can simply produce HTML and
+embed it in InlineHtmlBlock.
+
To use the new FsiEvaluator, we can use the same style as earlier. This time, we format
+a simple list containing strings:
The resulting HTML formatting of the document contains the snippet that defines test,
+followed by a nicely formatted ordered list:
+
+
Formatting demo
+
+1:
+
+
+
+lettest = ["one";"two";"three"]
+
+
+
+
+
one
+
two
+
three
+
+
+
+
val test: int
+
val printf: format: Printf.TextWriterFormat<'T> -> 'T
+
val value1: int list
+
val value2: int list
+
Multiple items namespace FSharp
-------------------- namespace Microsoft.FSharp
+
namespace FSharp.Formatting
+
namespace FSharp.Formatting.Literate
+
namespace FSharp.Formatting.Literate.Evaluation
+
namespace FSharp.Formatting.Markdown
+
val content: string
+
val fsi: FsiEvaluator
+
Multiple items type FsiEvaluator =
+ interface IFsiEvaluator
+ new: ?options: string array * ?fsiObj: obj * ?addHtmlPrinter: bool * ?discardStdOut: bool * ?disableFsiObj: bool * ?onError: (string -> unit) -> FsiEvaluator
+ member RegisterTransformation: f: (obj * Type * int -> MarkdownParagraph list option) -> unit
+ member EvaluationFailed: IEvent<FsiEvaluationFailedInfo> <summary>
+ A wrapper for F# interactive service that is used to evaluate inline snippets
+</summary>
val cast: source: System.Collections.IEnumerable -> 'T seq
+
type obj = System.Object
+
val unbox: value: obj -> 'T
+
union case MarkdownParagraph.Paragraph: body: MarkdownSpans * range: MarkdownRange option -> MarkdownParagraph
+
Multiple items union case MarkdownSpan.Literal: text: string * range: MarkdownRange option -> MarkdownSpan
-------------------- type LiteralAttribute =
+ inherit Attribute
+ new: unit -> LiteralAttribute
-------------------- new: unit -> LiteralAttribute
+
System.Object.ToString() : string
+
union case Option.None: Option<'T>
+
union case Option.Some: Value: 'T -> Option<'T>
+
union case MarkdownParagraph.ListBlock: kind: MarkdownListKind * items: MarkdownParagraphs list * range: MarkdownRange option -> MarkdownParagraph <summary>
+ A Markdown List block
+</summary>
+
[<Struct>]
+type MarkdownListKind =
+ | Ordered
+ | Unordered <summary>
+ A list kind can be Ordered or Unordered corresponding to <c><ol></c> and <c><ul></c> elements
+ </summary>
+
union case MarkdownListKind.Ordered: MarkdownListKind
+
val listy: string
+
val docOl: LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/evaluation.ipynb b/evaluation.ipynb
new file mode 100644
index 000000000..0967fd40a
--- /dev/null
+++ b/evaluation.ipynb
@@ -0,0 +1,347 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "#r \"nuget: FSharp.Formatting,1.0.0\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=evaluation.ipynb)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//evaluation.fsx)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//evaluation.ipynb)\n",
+ "\n",
+ "# Embedding script output\n",
+ "\n",
+ "For literate F# scripts, you may embed the result of running the script as part of the literate output.\n",
+ "This is a feature of the functions discussed in [literate programming](literate.html) and\n",
+ "it is implemented using the [F# Compiler service](http://fsharp.github.io/FSharp.Compiler.Service/).\n",
+ "\n",
+ "## Including Console Output\n",
+ "\n",
+ "To include the Console output use `include-output`:\n",
+ "\n",
+ " let test = 40 + 2\n",
+ "\n",
+ " printf \"A result is: %d\" test\n",
+ " (*** include-output ***)\n",
+ "\n",
+ "The script defines a variable `test` and then prints it. The console output is included\n",
+ "in the output.\n",
+ "\n",
+ "To include the a formatted value use `include-it`:\n",
+ "\n",
+ " [ 0 .. 99 ]\n",
+ "\n",
+ " (*** include-it ***)\n",
+ "\n",
+ "\n",
+ "To include the meta output of F# Interactive processing such as type signatures use `(*** include-fsi-output ***)`:\n",
+ "\n",
+ " let test = 40 + 3\n",
+ "\n",
+ " (*** include-fsi-output ***)\n",
+ "\n",
+ "To include both console otuput and F# Interactive output blended use `(*** include-fsi-merged-output ***)`.\n",
+ "\n",
+ " let test = 40 + 4\n",
+ " (*** include-fsi-merged-output ***)\n",
+ "\n",
+ "You can use the same commands with a named snippet:\n",
+ "\n",
+ " (*** include-it: test ***)\n",
+ " (*** include-fsi-output: test ***)\n",
+ " (*** include-output: test ***)\n",
+ "\n",
+ "You can use the `include-value` command to format a specific value:\n",
+ "\n",
+ " let value1 = [ 0 .. 50 ]\n",
+ " let value2 = [ 51 .. 100 ]\n",
+ " (*** include-value: value1 ***)\n",
+ "\n",
+ "## Using AddPrinter and AddHtmlPrinter\n",
+ "\n",
+ "You can use `fsi.AddPrinter`, `fsi.AddPrintTransformer` and `fsi.AddHtmlPrinter` to extend the formatting of objects.\n",
+ "\n",
+ "## Emitting Raw Text\n",
+ "\n",
+ "To emit raw text in F# literate scripts use the following:\n",
+ "\n",
+ "\t(**\n",
+ "\t\t(*** raw ***)\n",
+ "\t\tSome raw text.\n",
+ "\t*)\n",
+ "\n",
+ "which would emit\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "\u003cpre\u003e\n",
+ "Some raw text.\n",
+ "\u003c/pre\u003e\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "directly into the document.\n",
+ "\n",
+ "## F# Formatting as a Library: Specifying the Evaluator and Formatting\n",
+ "\n",
+ "If using F# Formatting as a library the embedding of F# output requires specifying an additional parameter to the\n",
+ "parsing functions discussed in [literate programming documentation](literate.html).\n",
+ "Assuming you have all the references in place, you can now create an instance of\n",
+ "[FsiEvaluator](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html) that represents a wrapper for F# interactive and pass it to all the\n",
+ "functions that parse script files or process script files:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "open FSharp.Formatting.Literate\n",
+ "open FSharp.Formatting.Literate.Evaluation\n",
+ "open FSharp.Formatting.Markdown\n",
+ "\n",
+ "// Sample literate content\n",
+ "let content =\n",
+ " \"\"\"\n",
+ "let a = 10\n",
+ "(*** include-value:a ***)\"\"\"\n",
+ "\n",
+ "// Create evaluator and parse script\n",
+ "let fsi = FsiEvaluator()\n",
+ "\n",
+ "let doc = Literate.ParseScriptString(content, fsiEvaluator = fsi)\n",
+ "\n",
+ "Literate.ToHtml(doc)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "When the `fsiEvaluator` parameter is specified, the script is evaluated and so you\n",
+ "can use additional commands such as `include-value`. When the evaluator is **not** specified,\n",
+ "it is not created automatically and so the functionality is not available (this way,\n",
+ "you won\u0027t accidentally run unexpected code!)\n",
+ "\n",
+ "If you specify the `fsiEvaluator` parameter, but don\u0027t want a specific snippet to be evaluated\n",
+ "(because it might throw an exception, for example), you can use the `(*** do-not-eval ***)`\n",
+ "command.\n",
+ "\n",
+ "The constructor of [FsiEvaluator](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html) takes command line parameters for `fsi.exe` that can\n",
+ "be used to specify, for example, defined symbols and other attributes for F# Interactive.\n",
+ "\n",
+ "You can also subscribe to the `EvaluationFailed` event which is fired whenever the evaluation\n",
+ "of an expression fails. You can use that to do tests that verify that all off the code in your\n",
+ "documentation executes without errors.\n",
+ "\n",
+ "## F# Formatting as a Library: Custom formatting functions\n",
+ "\n",
+ "As mentioned earlier, values are formatted using a simple `\"%A\"` formatter by default.\n",
+ "However, you can specify a formatting function that provides a nicer formatting for values\n",
+ "of certain types. For example, let\u0027s say that we would want to format F# lists such as\n",
+ "`[1; 2; 3]` as HTML ordered lists `\u003col\u003e`.\n",
+ "\n",
+ "This can be done by calling [FsiEvaluator.RegisterTransformation](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#RegisterTransformation) on the `FsiEvaluator` instance:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "// Create evaluator \u0026 register simple formatter for lists\n",
+ "let fsiEvaluator = FsiEvaluator()\n",
+ "\n",
+ "fsiEvaluator.RegisterTransformation(fun (o, ty, _executionCount) -\u003e\n",
+ " // If the type of value is an F# list, format it nicely\n",
+ " if ty.IsGenericType\n",
+ " \u0026\u0026 ty.GetGenericTypeDefinition() = typedefof\u003clist\u003c_\u003e\u003e then\n",
+ " let items =\n",
+ " // Get items as objects and create paragraph for each item\n",
+ " [ for it in Seq.cast\u003cobj\u003e (unbox o) -\u003e [ Paragraph([ Literal(it.ToString(), None) ], None) ] ]\n",
+ " // Return option value (success) with ordered list\n",
+ " Some [ ListBlock(MarkdownListKind.Ordered, items, None) ]\n",
+ " else\n",
+ " None)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The function is called with two arguments - `o` is the value to be formatted and `ty`\n",
+ "is the static type of the value (as inferred by the F# compiler). The sample checks\n",
+ "that the type of the value is a list (containing values of any type) and then it\n",
+ "casts all values in the list to `obj` (for simplicity). Then we generate Markdown\n",
+ "blocks representing an ordered list. This means that the code will work for both\n",
+ "LaTeX and HTML formatting - but if you only need one, you can simply produce HTML and\n",
+ "embed it in `InlineHtmlBlock`.\n",
+ "\n",
+ "To use the new `FsiEvaluator`, we can use the same style as earlier. This time, we format\n",
+ "a simple list containing strings:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let listy =\n",
+ " \"\"\"\n",
+ "### Formatting demo\n",
+ "let test = [\"one\";\"two\";\"three\"]\n",
+ "(*** include-value:test ***)\"\"\"\n",
+ "\n",
+ "let docOl = Literate.ParseScriptString(listy, fsiEvaluator = fsiEvaluator)\n",
+ "\n",
+ "Literate.ToHtml(docOl)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The resulting HTML formatting of the document contains the snippet that defines `test`,\n",
+ "followed by a nicely formatted ordered list:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "\u003cblockquote\u003e\n",
+ "\u003ch3\u003eFormatting demo\u003c/h3\u003e\n",
+ "\u003ctable class=\"pre\"\u003e\u003ctr\u003e\u003ctd class=\"lines\"\u003e\u003cpre class=\"fssnip\"\u003e\n",
+ "\u003cspan class=\"l\"\u003e1: \u003c/span\u003e\n",
+ "\u003c/pre\u003e\n",
+ "\u003c/td\u003e\n",
+ "\u003ctd class=\"snippet\"\u003e\u003cpre class=\"fssnip\"\u003e\n",
+ "\u003cspan class=\"k\"\u003elet\u003c/span\u003e \u003cspanclass=\"i\"\u003etest\u003c/span\u003e \u003cspan class=\"o\"\u003e=\u003c/span\u003e [\u003cspan class=\"s\"\u003e\u0026quot;\u003c/span\u003e\u003cspan class=\"s\"\u003eone\u003c/span\u003e\u003cspan class=\"s\"\u003e\u0026quot;\u003c/span\u003e;\u003cspan class=\"s\"\u003e\u0026quot;\u003c/span\u003e\u003cspan class=\"s\"\u003etwo\u003c/span\u003e\u003cspan class=\"s\"\u003e\u0026quot;\u003c/span\u003e;\u003cspan class=\"s\"\u003e\u0026quot;\u003c/span\u003e\u003cspan class=\"s\"\u003ethree\u003c/span\u003e\u003cspan class=\"s\"\u003e\u0026quot;\u003c/span\u003e]\u003c/pre\u003e\n",
+ "\u003c/td\u003e\n",
+ "\u003c/tr\u003e\n",
+ "\u003c/table\u003e\n",
+ "\u003col\u003e\n",
+ "\u003cli\u003e\u003cp\u003eone\u003c/p\u003e\u003c/li\u003e\n",
+ "\u003cli\u003e\u003cp\u003etwo\u003c/p\u003e\u003c/li\u003e\n",
+ "\u003cli\u003e\u003cp\u003ethree\u003c/p\u003e\u003c/li\u003e\n",
+ "\u003c/ol\u003e\n",
+ "\u003c/blockquote\u003e\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/evaluation.md b/evaluation.md
new file mode 100644
index 000000000..525622506
--- /dev/null
+++ b/evaluation.md
@@ -0,0 +1,205 @@
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=evaluation.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//evaluation.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//evaluation.ipynb)
+
+# Embedding script output
+
+For literate F# scripts, you may embed the result of running the script as part of the literate output.
+This is a feature of the functions discussed in [literate programming](literate.html) and
+it is implemented using the [F# Compiler service](http://fsharp.github.io/FSharp.Compiler.Service/).
+
+## Including Console Output
+
+To include the Console output use `include-output`:
+
+```fsharp
+let test = 40 + 2
+
+printf "A result is: %d" test
+(*** include-output ***)
+
+```
+
+The script defines a variable `test` and then prints it. The console output is included
+in the output.
+
+To include the a formatted value use `include-it`:
+
+```fsharp
+[ 0 .. 99 ]
+
+(*** include-it ***)
+
+```
+
+To include the meta output of F# Interactive processing such as type signatures use `(*** include-fsi-output ***)`:
+
+```fsharp
+let test = 40 + 3
+
+(*** include-fsi-output ***)
+
+```
+
+To include both console otuput and F# Interactive output blended use `(*** include-fsi-merged-output ***)`.
+
+```fsharp
+let test = 40 + 4
+(*** include-fsi-merged-output ***)
+
+```
+
+You can use the same commands with a named snippet:
+
+```fsharp
+(*** include-it: test ***)
+(*** include-fsi-output: test ***)
+(*** include-output: test ***)
+
+```
+
+You can use the `include-value` command to format a specific value:
+
+```fsharp
+let value1 = [ 0 .. 50 ]
+let value2 = [ 51 .. 100 ]
+(*** include-value: value1 ***)
+
+```
+
+## Using AddPrinter and AddHtmlPrinter
+
+You can use `fsi.AddPrinter`, `fsi.AddPrintTransformer` and `fsi.AddHtmlPrinter` to extend the formatting of objects.
+
+## Emitting Raw Text
+
+To emit raw text in F# literate scripts use the following:
+
+```fsharp
+(**
+ (*** raw ***)
+ Some raw text.
+*)
+
+```
+
+which would emit
+
+
+Some raw text.
+
+directly into the document.
+
+## F# Formatting as a Library: Specifying the Evaluator and Formatting
+
+If using F# Formatting as a library the embedding of F# output requires specifying an additional parameter to the
+parsing functions discussed in [literate programming documentation](literate.html).
+Assuming you have all the references in place, you can now create an instance of
+[FsiEvaluator](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html) that represents a wrapper for F# interactive and pass it to all the
+functions that parse script files or process script files:
+
+```fsharp
+open FSharp.Formatting.Literate
+open FSharp.Formatting.Literate.Evaluation
+open FSharp.Formatting.Markdown
+
+// Sample literate content
+let content =
+ """
+let a = 10
+(*** include-value:a ***)"""
+
+// Create evaluator and parse script
+let fsi = FsiEvaluator()
+
+let doc = Literate.ParseScriptString(content, fsiEvaluator = fsi)
+
+Literate.ToHtml(doc)
+```
+
+When the `fsiEvaluator` parameter is specified, the script is evaluated and so you
+can use additional commands such as `include-value`. When the evaluator is **not** specified,
+it is not created automatically and so the functionality is not available (this way,
+you won't accidentally run unexpected code!)
+
+If you specify the `fsiEvaluator` parameter, but don't want a specific snippet to be evaluated
+(because it might throw an exception, for example), you can use the `(*** do-not-eval ***)`
+command.
+
+The constructor of [FsiEvaluator](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html) takes command line parameters for `fsi.exe` that can
+be used to specify, for example, defined symbols and other attributes for F# Interactive.
+
+You can also subscribe to the `EvaluationFailed` event which is fired whenever the evaluation
+of an expression fails. You can use that to do tests that verify that all off the code in your
+documentation executes without errors.
+
+## F# Formatting as a Library: Custom formatting functions
+
+As mentioned earlier, values are formatted using a simple `"%A"` formatter by default.
+However, you can specify a formatting function that provides a nicer formatting for values
+of certain types. For example, let's say that we would want to format F# lists such as
+`[1; 2; 3]` as HTML ordered lists ``.
+
+This can be done by calling [FsiEvaluator.RegisterTransformation](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#RegisterTransformation) on the `FsiEvaluator` instance:
+
+```fsharp
+// Create evaluator & register simple formatter for lists
+let fsiEvaluator = FsiEvaluator()
+
+fsiEvaluator.RegisterTransformation(fun (o, ty, _executionCount) ->
+ // If the type of value is an F# list, format it nicely
+ if ty.IsGenericType
+ && ty.GetGenericTypeDefinition() = typedefof> then
+ let items =
+ // Get items as objects and create paragraph for each item
+ [ for it in Seq.cast (unbox o) -> [ Paragraph([ Literal(it.ToString(), None) ], None) ] ]
+ // Return option value (success) with ordered list
+ Some [ ListBlock(MarkdownListKind.Ordered, items, None) ]
+ else
+ None)
+```
+
+The function is called with two arguments - `o` is the value to be formatted and `ty`
+is the static type of the value (as inferred by the F# compiler). The sample checks
+that the type of the value is a list (containing values of any type) and then it
+casts all values in the list to `obj` (for simplicity). Then we generate Markdown
+blocks representing an ordered list. This means that the code will work for both
+LaTeX and HTML formatting - but if you only need one, you can simply produce HTML and
+embed it in `InlineHtmlBlock`.
+
+To use the new `FsiEvaluator`, we can use the same style as earlier. This time, we format
+a simple list containing strings:
+
+```fsharp
+let listy =
+ """
+### Formatting demo
+let test = ["one";"two";"three"]
+(*** include-value:test ***)"""
+
+let docOl = Literate.ParseScriptString(listy, fsiEvaluator = fsiEvaluator)
+
+Literate.ToHtml(docOl)
+```
+
+The resulting HTML formatting of the document contains the snippet that defines `test`,
+followed by a nicely formatted ordered list:
+
+
+
Formatting demo
+
+1:
+
+
+
+lettest = ["one";"two";"three"]
+
+
+
+
+
one
+
two
+
three
+
+
+
diff --git a/evaluation.tex b/evaluation.tex
new file mode 100644
index 000000000..466f65600
--- /dev/null
+++ b/evaluation.tex
@@ -0,0 +1,318 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+
+
+\href{https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=evaluation.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-binder.svg}
+\caption{Binder}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//evaluation.fsx}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-script.svg}
+\caption{Script}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//evaluation.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-notebook.svg}
+\caption{Notebook}
+\end{figure}
+}
+\section*{Embedding script output}
+
+
+
+For literate F\# scripts, you may embed the result of running the script as part of the literate output.
+This is a feature of the functions discussed in \href{literate.html}{literate programming} and
+it is implemented using the \href{http://fsharp.github.io/FSharp.Compiler.Service/}{F\# Compiler service}.
+\subsection*{Including Console Output}
+
+
+
+To include the Console output use \texttt{include-output}:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{test} \ops{=} \num{40} \ops{+} \num{2}
+
+\lfun{printf} \str{"A result is: }\lprf{\%d}\str{"} \id{test}
+\com{(*** include-output ***)}
+
+
+\end{lstlisting}
+
+
+
+The script defines a variable \texttt{test} and then prints it. The console output is included
+in the output.
+
+
+To include the a formatted value use \texttt{include-it}:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{[} \num{0} \ops{..} \num{99} {]}
+
+\com{(*** include-it ***)}
+
+
+\end{lstlisting}
+
+
+
+To include the meta output of F\# Interactive processing such as type signatures use \texttt{(*** include-fsi-output ***)}:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{test} \ops{=} \num{40} \ops{+} \num{3}
+
+\com{(*** include-fsi-output ***)}
+
+
+\end{lstlisting}
+
+
+
+To include both console otuput and F\# Interactive output blended use \texttt{(*** include-fsi-merged-output ***)}.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{test} \ops{=} \num{40} \ops{+} \num{4}
+\com{(*** include-fsi-merged-output ***)}
+
+
+\end{lstlisting}
+
+
+
+You can use the same commands with a named snippet:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{(*** include-it: test ***)}
+\com{(*** include-fsi-output: test ***)}
+\com{(*** include-output: test ***)}
+
+
+\end{lstlisting}
+
+
+
+You can use the \texttt{include-value} command to format a specific value:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{value1} \ops{=} {[} \num{0} \ops{..} \num{50} {]}
+\kwd{let} \id{value2} \ops{=} {[} \num{51} \ops{..} \num{100} {]}
+\com{(*** include-value: value1 ***)}
+
+
+\end{lstlisting}
+
+\subsection*{Using AddPrinter and AddHtmlPrinter}
+
+
+
+You can use \texttt{fsi.AddPrinter}, \texttt{fsi.AddPrintTransformer} and \texttt{fsi.AddHtmlPrinter} to extend the formatting of objects.
+\subsection*{Emitting Raw Text}
+
+
+
+To emit raw text in F\# literate scripts use the following:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{(**}
+\com{ (*** raw ***)}
+\com{ Some raw text.}
+\com{*)}
+
+
+\end{lstlisting}
+
+
+
+which would emit
+
+Some raw text.
+
+
+
+directly into the document.
+\subsection*{F\# Formatting as a Library: Specifying the Evaluator and Formatting}
+
+
+
+If using F\# Formatting as a library the embedding of F\# output requires specifying an additional parameter to the
+parsing functions discussed in \href{literate.html}{literate programming documentation}.
+Assuming you have all the references in place, you can now create an instance of
+\href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html}{FsiEvaluator} that represents a wrapper for F\# interactive and pass it to all the
+functions that parse script files or process script files:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{Literate}
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{Literate}{.}\id{Evaluation}
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{Markdown}
+
+\com{// Sample literate content}
+\kwd{let} \id{content} \ops{=}
+ \str{"""}
+\str{let a = 10}
+\str{(*** include-value:a ***)"""}
+
+\com{// Create evaluator and parse script}
+\kwd{let} \id{fsi} \ops{=} \lfun{FsiEvaluator}{(}{)}
+
+\kwd{let} \id{doc} \ops{=} \ltyp{Literate}{.}\id{ParseScriptString}{(}\id{content}{,} \lfun{fsiEvaluator} \ops{=} \id{fsi}{)}
+
+\ltyp{Literate}{.}\id{ToHtml}{(}\id{doc}{)}
+
+\end{lstlisting}
+
+
+
+When the \texttt{fsiEvaluator} parameter is specified, the script is evaluated and so you
+can use additional commands such as \texttt{include-value}. When the evaluator is \emph{not} specified,
+it is not created automatically and so the functionality is not available (this way,
+you won't accidentally run unexpected code!)
+
+
+If you specify the \texttt{fsiEvaluator} parameter, but don't want a specific snippet to be evaluated
+(because it might throw an exception, for example), you can use the \texttt{(*** do-not-eval ***)}
+command.
+
+
+The constructor of \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html}{FsiEvaluator} takes command line parameters for \texttt{fsi.exe} that can
+be used to specify, for example, defined symbols and other attributes for F\# Interactive.
+
+
+You can also subscribe to the \texttt{EvaluationFailed} event which is fired whenever the evaluation
+of an expression fails. You can use that to do tests that verify that all off the code in your
+documentation executes without errors.
+\subsection*{F\# Formatting as a Library: Custom formatting functions}
+
+
+
+As mentioned earlier, values are formatted using a simple \texttt{"\%A"} formatter by default.
+However, you can specify a formatting function that provides a nicer formatting for values
+of certain types. For example, let's say that we would want to format F\# lists such as
+\texttt{[1; 2; 3]} as HTML ordered lists \texttt{}.
+
+
+This can be done by calling \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html\#RegisterTransformation}{FsiEvaluator.RegisterTransformation} on the \texttt{FsiEvaluator} instance:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{// Create evaluator \& register simple formatter for lists}
+\kwd{let} \id{fsiEvaluator} \ops{=} \lfun{FsiEvaluator}{(}{)}
+
+\id{fsiEvaluator}{.}\id{RegisterTransformation}{(}\kwd{fun} {(}\lfun{o}{,} \lfun{ty}{,} \id{\_executionCount}{)} \kwd{->}
+ \com{// If the type of value is an F\# list, format it nicely}
+ \kwd{if} \lfun{ty}{.}\id{IsGenericType}
+ \ops{\&\&} \lfun{ty}{.}\id{GetGenericTypeDefinition}{(}{)} \ops{=} \kwd{typedefof}{<}\ltyp{list}{<}\id{\_}{>}{>} \kwd{then}
+ \kwd{let} \lfun{items} \ops{=}
+ \com{// Get items as objects and create paragraph for each item}
+ {[} \kwd{for} \lfun{it} \kwd{in} \ltyp{Seq}{.}\id{cast}{<}\ltyp{obj}{>} {(}\lfun{unbox} \lfun{o}{)} \kwd{->} {[} {Paragraph}{(}{[} {Literal}{(}\lfun{it}{.}\id{ToString}{(}{)}{,} {None}{)} {]}{,} {None}{)} {]} {]}
+ \com{// Return option value (success) with ordered list}
+ {Some} {[} {ListBlock}{(}\ltyp{MarkdownListKind}{.}\id{Ordered}{,} \lfun{items}{,} {None}{)} {]}
+ \kwd{else}
+ {None}{)}
+
+\end{lstlisting}
+
+
+
+The function is called with two arguments - \texttt{o} is the value to be formatted and \texttt{ty}
+is the static type of the value (as inferred by the F\# compiler). The sample checks
+that the type of the value is a list (containing values of any type) and then it
+casts all values in the list to \texttt{obj} (for simplicity). Then we generate Markdown
+blocks representing an ordered list. This means that the code will work for both
+LaTeX and HTML formatting - but if you only need one, you can simply produce HTML and
+embed it in \texttt{InlineHtmlBlock}.
+
+
+To use the new \texttt{FsiEvaluator}, we can use the same style as earlier. This time, we format
+a simple list containing strings:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{listy} \ops{=}
+ \str{"""}
+\str{\#\#\# Formatting demo}
+\str{let test = ["one";"two";"three"]}
+\str{(*** include-value:test ***)"""}
+
+\kwd{let} \id{docOl} \ops{=} \ltyp{Literate}{.}\id{ParseScriptString}{(}\id{listy}{,} \lfun{fsiEvaluator} \ops{=} \id{fsiEvaluator}{)}
+
+\ltyp{Literate}{.}\id{ToHtml}{(}\id{docOl}{)}
+
+\end{lstlisting}
+
+
+
+The resulting HTML formatting of the document contains the snippet that defines \texttt{test},
+followed by a nicely formatted ordered list:
+
+
Formatting demo
+
+1:
+
+
+
+lettest = ["one";"two";"three"]
+
+
+
+
+
one
+
two
+
three
+
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/img/badge-binder.svg b/img/badge-binder.svg
new file mode 100644
index 000000000..8df9f49a7
--- /dev/null
+++ b/img/badge-binder.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/img/badge-notebook.svg b/img/badge-notebook.svg
new file mode 100644
index 000000000..a001b5449
--- /dev/null
+++ b/img/badge-notebook.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/img/badge-script.svg b/img/badge-script.svg
new file mode 100644
index 000000000..90c93ebe5
--- /dev/null
+++ b/img/badge-script.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/img/favicon.ico b/img/favicon.ico
new file mode 100644
index 000000000..1b43557a9
Binary files /dev/null and b/img/favicon.ico differ
diff --git a/img/logo.pdn b/img/logo.pdn
new file mode 100644
index 000000000..70ad16af7
Binary files /dev/null and b/img/logo.pdn differ
diff --git a/img/logo.png b/img/logo.png
new file mode 100644
index 000000000..32942ab65
Binary files /dev/null and b/img/logo.png differ
diff --git a/index.fsx b/index.fsx
new file mode 100644
index 000000000..f17f30172
--- /dev/null
+++ b/index.fsx
@@ -0,0 +1,63 @@
+(**
+# F# Formatting: Documentation Tools for F# Code
+
+FSharp.Formatting is a set of libraries and tools for processing F# script files, markdown and for
+generating API documentation. F# Formatting package is used by this project and many other repositories.
+
+To use the tool, install and use the [fsdocs](commandline.html) tool in a typical F# project with
+F# project files plus markdown and script content in the `docs` directory:
+
+ dotnet tool install fsdocs-tool
+ dotnet fsdocs build
+ dotnet fsdocs watch
+
+To use the tool, explore the following topics:
+
+* [Authoring Content](content.html) - explains the content expected in the `docs` directory for the `fsdocs` tool.
+
+
+* [Using the Command line tool](commandline.html) - explains how to use the `fsdocs` tool.
+
+
+* [Generating API documentation](apidocs.html) - how to generate HTML documentation
+from "XML comments" in your .NET libraries. The tool handles comments written in
+Markdown too.
+
+
+* [Styling](styling.html) - explains some options for styling the output of `fsdocs`.
+
+
+* [Using literate programming](literate.html) - explains how to generate documentation
+for your projects or to write nicely formatted F# blog posts.
+
+
+* [Embedding F# outputs in literate programming](evaluation.html) - provides more details on literate programming and
+explains how to embed results of a literate script file in the generated output. This way,
+you can easily format the results of running your code!
+
+
+## Using FSharp.Formatting as a library
+
+F# Formatting is also [available on NuGet](https://nuget.org/packages/FSharp.Formatting) as a set of libraries.
+
+* [Markdown parser](markdown.html) - explains the F# Markdown
+processor that is available in this library with some basic examples of
+document processing.
+
+
+* [F# code formatting](codeformat.html) - more details about the F# code
+formatter and how to use it to obtain information about F# source files.
+
+
+## More information
+
+The documentation for this library is generated automatically using the tools
+built here. If you spot a typo, please submit a pull request! The source Markdown and F# script files are
+available in the [docs folder on GitHub](https://github.com/fsprojects/FSharp.Formatting/tree/master/docs).
+
+The project is hosted on [GitHub](https://github.com/fsprojects/FSharp.Formatting) where you can
+[report issues](https://github.com/fsprojects/FSharp.Formatting/issues), fork the project and submit pull requests.
+See the [License file](https://github.com/fsprojects/FSharp.Formatting/blob/master/LICENSE.md) in the GitHub repository.
+
+*)
+
diff --git a/index.html b/index.html
new file mode 100644
index 000000000..7c0b34c31
--- /dev/null
+++ b/index.html
@@ -0,0 +1,382 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ F# Formatting: Documentation Tools for F# Code
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
FSharp.Formatting is a set of libraries and tools for processing F# script files, markdown and for
+generating API documentation. F# Formatting package is used by this project and many other repositories.
+
To use the tool, install and use the fsdocs tool in a typical F# project with
+F# project files plus markdown and script content in the docs directory:
Generating API documentation - how to generate HTML documentation
+from "XML comments" in your .NET libraries. The tool handles comments written in
+Markdown too.
+
+
Styling - explains some options for styling the output of fsdocs.
+
+
Using literate programming - explains how to generate documentation
+for your projects or to write nicely formatted F# blog posts.
+
+
+
Embedding F# outputs in literate programming - provides more details on literate programming and
+explains how to embed results of a literate script file in the generated output. This way,
+you can easily format the results of running your code!
The documentation for this library is generated automatically using the tools
+built here. If you spot a typo, please submit a pull request! The source Markdown and F# script files are
+available in the docs folder on GitHub.
+
The project is hosted on GitHub where you can
+report issues, fork the project and submit pull requests.
+See the License file in the GitHub repository.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/index.ipynb b/index.ipynb
new file mode 100644
index 000000000..7217406fd
--- /dev/null
+++ b/index.ipynb
@@ -0,0 +1,100 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# F# Formatting: Documentation Tools for F# Code\n",
+ "\n",
+ "FSharp.Formatting is a set of libraries and tools for processing F# script files, markdown and for\n",
+ "generating API documentation. F# Formatting package is used by this project and many other repositories.\n",
+ "\n",
+ "To use the tool, install and use the [fsdocs](commandline.html) tool in a typical F# project with\n",
+ "F# project files plus markdown and script content in the `docs` directory:\n",
+ "\n",
+ " dotnet tool install fsdocs-tool\n",
+ " dotnet fsdocs build \n",
+ " dotnet fsdocs watch\n",
+ "\n",
+ "To use the tool, explore the following topics:\n",
+ "\n",
+ "* [Authoring Content](content.html) - explains the content expected in the `docs` directory for the `fsdocs` tool.\n",
+ " \n",
+ "\n",
+ "* [Using the Command line tool](commandline.html) - explains how to use the `fsdocs` tool.\n",
+ " \n",
+ "\n",
+ "* [Generating API documentation](apidocs.html) - how to generate HTML documentation\n",
+ "from \"XML comments\" in your .NET libraries. The tool handles comments written in\n",
+ "Markdown too.\n",
+ " \n",
+ "\n",
+ "* [Styling](styling.html) - explains some options for styling the output of `fsdocs`.\n",
+ " \n",
+ "\n",
+ "* [Using literate programming](literate.html) - explains how to generate documentation\n",
+ "for your projects or to write nicely formatted F# blog posts.\n",
+ " \n",
+ "\n",
+ "* [Embedding F# outputs in literate programming](evaluation.html) - provides more details on literate programming and\n",
+ "explains how to embed results of a literate script file in the generated output. This way,\n",
+ "you can easily format the results of running your code!\n",
+ " \n",
+ "\n",
+ "## Using FSharp.Formatting as a library\n",
+ "\n",
+ "F# Formatting is also [available on NuGet](https://nuget.org/packages/FSharp.Formatting) as a set of libraries.\n",
+ "\n",
+ "* [Markdown parser](markdown.html) - explains the F# Markdown\n",
+ "processor that is available in this library with some basic examples of\n",
+ "document processing.\n",
+ " \n",
+ "\n",
+ "* [F# code formatting](codeformat.html) - more details about the F# code\n",
+ "formatter and how to use it to obtain information about F# source files.\n",
+ " \n",
+ "\n",
+ "## More information\n",
+ "\n",
+ "The documentation for this library is generated automatically using the tools\n",
+ "built here. If you spot a typo, please submit a pull request! The source Markdown and F# script files are\n",
+ "available in the [docs folder on GitHub](https://github.com/fsprojects/FSharp.Formatting/tree/master/docs).\n",
+ "\n",
+ "The project is hosted on [GitHub](https://github.com/fsprojects/FSharp.Formatting) where you can\n",
+ "[report issues](https://github.com/fsprojects/FSharp.Formatting/issues), fork the project and submit pull requests.\n",
+ "See the [License file](https://github.com/fsprojects/FSharp.Formatting/blob/master/LICENSE.md) in the GitHub repository.\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/index.json b/index.json
new file mode 100644
index 000000000..ee472cb1c
--- /dev/null
+++ b/index.json
@@ -0,0 +1 @@
+[{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs.html","title":"FSharp.Formatting.ApiDocs","content":"ApiDocAttribute \nApiDocCollection \nApiDocComment \nApiDocEntity \nApiDocEntityInfo \nApiDocFileExtensions \nApiDocHtml \nApiDocInput \nApiDocMember \nApiDocMemberDetails \nApiDocMemberKind \nApiDocModel \nApiDocNamespace \nApiDocType \nApiDocs \nApiDocsSearchIndexEntry \nAttribute \nDocComment \nMember \nMemberKind \nModule \nModuleInfo \nType \nTypeInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat.html","title":"FSharp.Formatting.CSharpFormat","content":"CLikeFormat \nCPlusPlusFormat \nCSharpFormat \nCodeFormat \nFSharpFormat \nHaskellFormat \nHtmlFormat \nJavaScriptFormat \nMshFormat \nPaketFormat \nPhpFormat \nSourceFormat \nSyntaxHighlighter \nTsqlFormat \nTypeScriptFormat \nVisualBasicFormat","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat.html","title":"FSharp.Formatting.CodeFormat","content":"CodeFormatter \nCodeFormat \nErrorKind \nFormattedContent \nFormattedSnippet \nLine \nSnippet \nSourceError \nTokenKind \nTokenSpan \nTokenSpans \nToolTipSpan \nToolTipSpans","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common.html","title":"FSharp.Formatting.Common","content":"Menu \nPageContentList","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate.html","title":"FSharp.Formatting.Literate","content":"MarkdownPatterns \nIndexText \nLiterate \nLiterateCodeOptions \nLiterateCodeVisibility \nLiterateDocument \nLiterateParagraph \nLiterateParagraphOptions \nLiterateSource \nOutputKind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation.html","title":"FSharp.Formatting.Literate.Evaluation","content":"FsiEmbedKind \nFsiEvaluationFailedInfo \nFsiEvaluationResult \nFsiEvaluator \nFsiEvaluatorConfig \nIFsiEvaluationResult \nIFsiEvaluator","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown.html","title":"FSharp.Formatting.Markdown","content":"Dsl \nHtmlFormatting \nMarkdownPatterns \nMarkdown \nMarkdownColumnAlignment \nMarkdownDocument \nMarkdownEmbedParagraphs \nMarkdownEmbedSpans \nMarkdownListKind \nMarkdownParagraph \nMarkdownParagraphs \nMarkdownParseOptions \nMarkdownSpan \nMarkdownSpans \nMarkdownTableRow \nMarkdownRange \nMarkdownRange","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating.html","title":"FSharp.Formatting.Templating","content":"ParamKeys \nFrontMatterFile \nParamKey \nSubstitutions","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html","title":"ApiDocAttribute","content":"ApiDocAttribute \n Represents a custom attribute attached to source code \nApiDocAttribute.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocAttribute.Format \nFormat \nApiDocAttribute.FormatFullName \nFormatFullName \nApiDocAttribute.FormatFullNameLongForm \nFormatFullNameLongForm \nApiDocAttribute.FormatLongForm \nFormatLongForm \nApiDocAttribute.IsCustomOperationAttribute \nIsCustomOperationAttribute \nApiDocAttribute.Name \nName \nApiDocAttribute.NamedConstructorArguments \nNamedConstructorArguments \nApiDocAttribute.ObsoleteMessage \nObsoleteMessage \nApiDocAttribute.FullName \nFullName \nApiDocAttribute.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \nApiDocAttribute.ConstructorArguments \nConstructorArguments \nApiDocAttribute.CustomOperationName \nCustomOperationName \nApiDocAttribute.IsObsoleteAttribute \nIsObsoleteAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocAttribute.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocAttribute.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#Format","title":"ApiDocAttribute.Format","content":"ApiDocAttribute.Format \nFormat \n Formats the attribute using the Name. Removes the \u0022Attribute\u0022-suffix. E.g Obsolete","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FormatFullName","title":"ApiDocAttribute.FormatFullName","content":"ApiDocAttribute.FormatFullName \nFormatFullName \n Formats the attribute using the FullName. Removes the \u0022Attribute\u0022-suffix. E.g System.Obsolete","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FormatFullNameLongForm","title":"ApiDocAttribute.FormatFullNameLongForm","content":"ApiDocAttribute.FormatFullNameLongForm \nFormatFullNameLongForm \n Formats the attribute using the FullName. Keeps the \u0022Attribute\u0022-suffix. E.g System.ObsoleteAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FormatLongForm","title":"ApiDocAttribute.FormatLongForm","content":"ApiDocAttribute.FormatLongForm \nFormatLongForm \n Formats the attribute using the Name. Keeps the \u0022Attribute\u0022-suffix. E.g ObsoleteAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#IsCustomOperationAttribute","title":"ApiDocAttribute.IsCustomOperationAttribute","content":"ApiDocAttribute.IsCustomOperationAttribute \nIsCustomOperationAttribute \n Gets a value indicating whether this attribute the CustomOperationAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#Name","title":"ApiDocAttribute.Name","content":"ApiDocAttribute.Name \nName \n The name of the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#NamedConstructorArguments","title":"ApiDocAttribute.NamedConstructorArguments","content":"ApiDocAttribute.NamedConstructorArguments \nNamedConstructorArguments \n The named arguments for the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#ObsoleteMessage","title":"ApiDocAttribute.ObsoleteMessage","content":"ApiDocAttribute.ObsoleteMessage \nObsoleteMessage \n Returns the obsolete message, when this attribute is the System.ObsoleteAttribute. When its not or no message was specified, an empty string is returned","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FullName","title":"ApiDocAttribute.FullName","content":"ApiDocAttribute.FullName \nFullName \n The qualified name of the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#IsRequireQualifiedAccessAttribute","title":"ApiDocAttribute.IsRequireQualifiedAccessAttribute","content":"ApiDocAttribute.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \n Gets a value indicating whether this attribute is RequireQualifiedAccessAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#ConstructorArguments","title":"ApiDocAttribute.ConstructorArguments","content":"ApiDocAttribute.ConstructorArguments \nConstructorArguments \n The arguments to the constructor for the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#CustomOperationName","title":"ApiDocAttribute.CustomOperationName","content":"ApiDocAttribute.CustomOperationName \nCustomOperationName \n Returns the custom operation name, when this attribute is the CustomOperationAttribute. When its not an empty string is returned","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#IsObsoleteAttribute","title":"ApiDocAttribute.IsObsoleteAttribute","content":"ApiDocAttribute.IsObsoleteAttribute \nIsObsoleteAttribute \n Gets a value indicating whether this attribute is System.ObsoleteAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html","title":"ApiDocCollection","content":"ApiDocCollection \n Represents a group of assemblies integrated with its associated documentation \nApiDocCollection.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocCollection.Assemblies \nAssemblies \nApiDocCollection.Namespaces \nNamespaces \nApiDocCollection.CollectionName \nCollectionName","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocCollection.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocCollection.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#Assemblies","title":"ApiDocCollection.Assemblies","content":"ApiDocCollection.Assemblies \nAssemblies \n All assemblies in the collection","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#Namespaces","title":"ApiDocCollection.Namespaces","content":"ApiDocCollection.Namespaces \nNamespaces \n All namespaces in the collection","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#CollectionName","title":"ApiDocCollection.CollectionName","content":"ApiDocCollection.CollectionName \nCollectionName \n Name of the collection","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html","title":"ApiDocComment","content":"ApiDocComment \n Represents a documentation comment attached to source code \nApiDocComment.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocComment.Summary \nSummary \nApiDocComment.Examples \nExamples \nApiDocComment.Returns \nReturns \nApiDocComment.Exceptions \nExceptions \nApiDocComment.Xml \nXml \nApiDocComment.RawData \nRawData \nApiDocComment.Remarks \nRemarks \nApiDocComment.Parameters \nParameters \nApiDocComment.Notes \nNotes","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocComment.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocComment.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Summary","title":"ApiDocComment.Summary","content":"ApiDocComment.Summary \nSummary \n The summary for the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Examples","title":"ApiDocComment.Examples","content":"ApiDocComment.Examples \nExamples \n The examples sections of the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Returns","title":"ApiDocComment.Returns","content":"ApiDocComment.Returns \nReturns \n The return sections of the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Exceptions","title":"ApiDocComment.Exceptions","content":"ApiDocComment.Exceptions \nExceptions \n The notes sections of the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Xml","title":"ApiDocComment.Xml","content":"ApiDocComment.Xml \nXml \n The XElement for the XML doc if available","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#RawData","title":"ApiDocComment.RawData","content":"ApiDocComment.RawData \nRawData \n The raw data of the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Remarks","title":"ApiDocComment.Remarks","content":"ApiDocComment.Remarks \nRemarks \n The remarks html for comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Parameters","title":"ApiDocComment.Parameters","content":"ApiDocComment.Parameters \nParameters \n The param sections of the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Notes","title":"ApiDocComment.Notes","content":"ApiDocComment.Notes \nNotes \n The notes sections of the comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html","title":"ApiDocEntity","content":"ApiDocEntity \n Represents a type definition integrated with its associated documentation \nApiDocEntity.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocEntity.OutputFile \nOutputFile \nApiDocEntity.Url \nUrl \nApiDocEntity.Constructors \nConstructors \nApiDocEntity.SourceLocation \nSourceLocation \nApiDocEntity.RecordFields \nRecordFields \nApiDocEntity.Name \nName \nApiDocEntity.StaticMembers \nStaticMembers \nApiDocEntity.Assembly \nAssembly \nApiDocEntity.Attributes \nAttributes \nApiDocEntity.UrlBaseName \nUrlBaseName \nApiDocEntity.AllInterfaces \nAllInterfaces \nApiDocEntity.CategoryIndex \nCategoryIndex \nApiDocEntity.InstanceMembers \nInstanceMembers \nApiDocEntity.ObsoleteMessage \nObsoleteMessage \nApiDocEntity.ActivePatterns \nActivePatterns \nApiDocEntity.Exclude \nExclude \nApiDocEntity.RequiresQualifiedAccess \nRequiresQualifiedAccess \nApiDocEntity.UnionCases \nUnionCases \nApiDocEntity.Substitutions \nSubstitutions \nApiDocEntity.Symbol \nSymbol \nApiDocEntity.TypeExtensions \nTypeExtensions \nApiDocEntity.IsTypeDefinition \nIsTypeDefinition \nApiDocEntity.AbbreviatedType \nAbbreviatedType \nApiDocEntity.NestedEntities \nNestedEntities \nApiDocEntity.AllMembers \nAllMembers \nApiDocEntity.DelegateSignature \nDelegateSignature \nApiDocEntity.BaseType \nBaseType \nApiDocEntity.IsObsolete \nIsObsolete \nApiDocEntity.Comment \nComment \nApiDocEntity.Category \nCategory \nApiDocEntity.StaticParameters \nStaticParameters \nApiDocEntity.ValuesAndFuncs \nValuesAndFuncs \nApiDocEntity.GetUrl \nGetUrl","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocEntity.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocEntity.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#OutputFile","title":"ApiDocEntity.OutputFile","content":"ApiDocEntity.OutputFile \nOutputFile \n The name of the file generated for this entity","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Url","title":"ApiDocEntity.Url","content":"ApiDocEntity.Url \nUrl \n The URL of the best link for the entity relative to \u0022reference\u0022 directory (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Constructors","title":"ApiDocEntity.Constructors","content":"ApiDocEntity.Constructors \nConstructors \n The constuctorsof the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#SourceLocation","title":"ApiDocEntity.SourceLocation","content":"ApiDocEntity.SourceLocation \nSourceLocation \n The URL of the member\u0027s source location, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#RecordFields","title":"ApiDocEntity.RecordFields","content":"ApiDocEntity.RecordFields \nRecordFields \n The fields of a record type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Name","title":"ApiDocEntity.Name","content":"ApiDocEntity.Name \nName \n The name of the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#StaticMembers","title":"ApiDocEntity.StaticMembers","content":"ApiDocEntity.StaticMembers \nStaticMembers \n The static members of the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Assembly","title":"ApiDocEntity.Assembly","content":"ApiDocEntity.Assembly \nAssembly \n The name of the type\u0027s assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Attributes","title":"ApiDocEntity.Attributes","content":"ApiDocEntity.Attributes \nAttributes \n The declared attributes of the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#UrlBaseName","title":"ApiDocEntity.UrlBaseName","content":"ApiDocEntity.UrlBaseName \nUrlBaseName \n The URL base name of the primary documentation for the entity (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#AllInterfaces","title":"ApiDocEntity.AllInterfaces","content":"ApiDocEntity.AllInterfaces \nAllInterfaces \n All interfaces of the type, formatted","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#CategoryIndex","title":"ApiDocEntity.CategoryIndex","content":"ApiDocEntity.CategoryIndex \nCategoryIndex \n The category index of the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#InstanceMembers","title":"ApiDocEntity.InstanceMembers","content":"ApiDocEntity.InstanceMembers \nInstanceMembers \n The instance members of the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#ObsoleteMessage","title":"ApiDocEntity.ObsoleteMessage","content":"ApiDocEntity.ObsoleteMessage \nObsoleteMessage \n Returns the obsolete message, when this member is obsolete. When its not or no message was specified, an empty string is returned","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#ActivePatterns","title":"ApiDocEntity.ActivePatterns","content":"ApiDocEntity.ActivePatterns \nActivePatterns \n Active patterns of the module","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Exclude","title":"ApiDocEntity.Exclude","content":"ApiDocEntity.Exclude \nExclude \n The exclude flag","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#RequiresQualifiedAccess","title":"ApiDocEntity.RequiresQualifiedAccess","content":"ApiDocEntity.RequiresQualifiedAccess \nRequiresQualifiedAccess \n Does the module have the RequiresQualifiedAccess attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#UnionCases","title":"ApiDocEntity.UnionCases","content":"ApiDocEntity.UnionCases \nUnionCases \n The cases of a union type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Substitutions","title":"ApiDocEntity.Substitutions","content":"ApiDocEntity.Substitutions \nSubstitutions \n The substitution parameters active for generating thist content","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Symbol","title":"ApiDocEntity.Symbol","content":"ApiDocEntity.Symbol \nSymbol \n The F# compiler symbol for the type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#TypeExtensions","title":"ApiDocEntity.TypeExtensions","content":"ApiDocEntity.TypeExtensions \nTypeExtensions \n Type extensions of the module","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#IsTypeDefinition","title":"ApiDocEntity.IsTypeDefinition","content":"ApiDocEntity.IsTypeDefinition \nIsTypeDefinition \n Indicates if the entity is a type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#AbbreviatedType","title":"ApiDocEntity.AbbreviatedType","content":"ApiDocEntity.AbbreviatedType \nAbbreviatedType \n If this is a type abbreviation, then the abbreviated type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#NestedEntities","title":"ApiDocEntity.NestedEntities","content":"ApiDocEntity.NestedEntities \nNestedEntities \n All nested modules and types","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#AllMembers","title":"ApiDocEntity.AllMembers","content":"ApiDocEntity.AllMembers \nAllMembers \n All members of the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#DelegateSignature","title":"ApiDocEntity.DelegateSignature","content":"ApiDocEntity.DelegateSignature \nDelegateSignature \n If this is a delegate, then e formatted signature","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#BaseType","title":"ApiDocEntity.BaseType","content":"ApiDocEntity.BaseType \nBaseType \n The base type of the type, formatted","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#IsObsolete","title":"ApiDocEntity.IsObsolete","content":"ApiDocEntity.IsObsolete \nIsObsolete \n Gets a value indicating whether this member is obsolete","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Comment","title":"ApiDocEntity.Comment","content":"ApiDocEntity.Comment \nComment \n The attached comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Category","title":"ApiDocEntity.Category","content":"ApiDocEntity.Category \nCategory \n The category of the type","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#StaticParameters","title":"ApiDocEntity.StaticParameters","content":"ApiDocEntity.StaticParameters \nStaticParameters \n Static parameters","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#ValuesAndFuncs","title":"ApiDocEntity.ValuesAndFuncs","content":"ApiDocEntity.ValuesAndFuncs \nValuesAndFuncs \n Values and functions of the module","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#GetUrl","title":"ApiDocEntity.GetUrl","content":"ApiDocEntity.GetUrl \nGetUrl \n Compute the URL of the best link for the entity relative to \u0022reference\u0022 directory (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html","title":"ApiDocEntityInfo","content":"ApiDocEntityInfo \n High-level information about a module definition \nApiDocEntityInfo.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocEntityInfo.Collection \nCollection \nApiDocEntityInfo.ParentModule \nParentModule \nApiDocEntityInfo.Namespace \nNamespace \nApiDocEntityInfo.Entity \nEntity","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocEntityInfo.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocEntityInfo.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#Collection","title":"ApiDocEntityInfo.Collection","content":"ApiDocEntityInfo.Collection \nCollection \n The collection of assemblies the entity belongs to","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#ParentModule","title":"ApiDocEntityInfo.ParentModule","content":"ApiDocEntityInfo.ParentModule \nParentModule \n The parent module, if any.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#Namespace","title":"ApiDocEntityInfo.Namespace","content":"ApiDocEntityInfo.Namespace \nNamespace \n The namespace the entity belongs to","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#Entity","title":"ApiDocEntityInfo.Entity","content":"ApiDocEntityInfo.Entity \nEntity \n The actual entity","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocfileextensions.html","title":"ApiDocFileExtensions","content":"ApiDocFileExtensions \n \nApiDocFileExtensions.InFile \nInFile \nApiDocFileExtensions.InUrl \nInUrl","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocfileextensions.html#InFile","title":"ApiDocFileExtensions.InFile","content":"ApiDocFileExtensions.InFile \nInFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocfileextensions.html#InUrl","title":"ApiDocFileExtensions.InUrl","content":"ApiDocFileExtensions.InUrl \nInUrl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html","title":"ApiDocHtml","content":"ApiDocHtml \n Represents some HTML formatted by model generation \nApiDocHtml.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocHtml.Id \nId \nApiDocHtml.HtmlText \nHtmlText","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocHtml.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocHtml.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html#Id","title":"ApiDocHtml.Id","content":"ApiDocHtml.Id \nId \n Get the Id of the element when rendered to html, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html#HtmlText","title":"ApiDocHtml.HtmlText","content":"ApiDocHtml.HtmlText \nHtmlText \n Get the HTML text of the HTML section","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html","title":"ApiDocInput","content":"ApiDocInput \n Represents an input assembly for API doc generation \nApiDocInput.FromFile \nFromFile \nApiDocInput.Path \nPath \nApiDocInput.XmlFile \nXmlFile \nApiDocInput.SourceFolder \nSourceFolder \nApiDocInput.SourceRepo \nSourceRepo \nApiDocInput.Substitutions \nSubstitutions \nApiDocInput.MarkdownComments \nMarkdownComments \nApiDocInput.Warn \nWarn \nApiDocInput.PublicOnly \nPublicOnly","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#FromFile","title":"ApiDocInput.FromFile","content":"ApiDocInput.FromFile \nFromFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#Path","title":"ApiDocInput.Path","content":"ApiDocInput.Path \nPath \n The path to the assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#XmlFile","title":"ApiDocInput.XmlFile","content":"ApiDocInput.XmlFile \nXmlFile \n Override the default XML file (normally assumed to live alongside)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#SourceFolder","title":"ApiDocInput.SourceFolder","content":"ApiDocInput.SourceFolder \nSourceFolder \n The compile-time source folder","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#SourceRepo","title":"ApiDocInput.SourceRepo","content":"ApiDocInput.SourceRepo \nSourceRepo \n The URL the the source repo where the source code lives","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#Substitutions","title":"ApiDocInput.Substitutions","content":"ApiDocInput.Substitutions \nSubstitutions \n The substitutionss active for this input. If specified these\n are used instead of the overall substitutions. This allows different parameters (e.g.\n different authors) for each assembly in a collection.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#MarkdownComments","title":"ApiDocInput.MarkdownComments","content":"ApiDocInput.MarkdownComments \nMarkdownComments \n Whether the input uses markdown comments","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#Warn","title":"ApiDocInput.Warn","content":"ApiDocInput.Warn \nWarn \n Whether doc processing should warn on missing comments","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#PublicOnly","title":"ApiDocInput.PublicOnly","content":"ApiDocInput.PublicOnly \nPublicOnly \n Whether to generate only public things","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html","title":"ApiDocMember","content":"ApiDocMember \n Represents an method, property, constructor, function or value, record field, union case or static parameter\n integrated with its associated documentation. Includes extension members. \nApiDocMember.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocMember.Url \nUrl \nApiDocMember.SourceLocation \nSourceLocation \nApiDocMember.Details \nDetails \nApiDocMember.Modifiers \nModifiers \nApiDocMember.UsageHtml \nUsageHtml \nApiDocMember.FormatCompiledName \nFormatCompiledName \nApiDocMember.ExtendedType \nExtendedType \nApiDocMember.Name \nName \nApiDocMember.FormatTypeArguments \nFormatTypeArguments \nApiDocMember.Kind \nKind \nApiDocMember.ReturnInfo \nReturnInfo \nApiDocMember.Attributes \nAttributes \nApiDocMember.UrlBaseName \nUrlBaseName \nApiDocMember.CategoryIndex \nCategoryIndex \nApiDocMember.ObsoleteMessage \nObsoleteMessage \nApiDocMember.Exclude \nExclude \nApiDocMember.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \nApiDocMember.Symbol \nSymbol \nApiDocMember.TypeArguments \nTypeArguments \nApiDocMember.FormatModifiers \nFormatModifiers \nApiDocMember.CustomOperationName \nCustomOperationName \nApiDocMember.CompiledName \nCompiledName \nApiDocMember.Parameters \nParameters \nApiDocMember.IsObsolete \nIsObsolete \nApiDocMember.Comment \nComment \nApiDocMember.Category \nCategory \nApiDocMember.GetUrl \nGetUrl","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocMember.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocMember.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Url","title":"ApiDocMember.Url","content":"ApiDocMember.Url \nUrl \n The URL of the best link documentation for the item relative to \u0022reference\u0022 directory (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#SourceLocation","title":"ApiDocMember.SourceLocation","content":"ApiDocMember.SourceLocation \nSourceLocation \n The URL of the member\u0027s source location, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Details","title":"ApiDocMember.Details","content":"ApiDocMember.Details \nDetails \n The members details","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Modifiers","title":"ApiDocMember.Modifiers","content":"ApiDocMember.Modifiers \nModifiers \n The member\u0027s modifiers","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#UsageHtml","title":"ApiDocMember.UsageHtml","content":"ApiDocMember.UsageHtml \nUsageHtml \n The usage section in a typical tooltip","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#FormatCompiledName","title":"ApiDocMember.FormatCompiledName","content":"ApiDocMember.FormatCompiledName \nFormatCompiledName \n Formats the compiled name","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#ExtendedType","title":"ApiDocMember.ExtendedType","content":"ApiDocMember.ExtendedType \nExtendedType \n The type extended by an extension member, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Name","title":"ApiDocMember.Name","content":"ApiDocMember.Name \nName \n Name of the member","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#FormatTypeArguments","title":"ApiDocMember.FormatTypeArguments","content":"ApiDocMember.FormatTypeArguments \nFormatTypeArguments \n Formats type arguments","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Kind","title":"ApiDocMember.Kind","content":"ApiDocMember.Kind \nKind \n The kind of the member","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#ReturnInfo","title":"ApiDocMember.ReturnInfo","content":"ApiDocMember.ReturnInfo \nReturnInfo \n The return section in a typical tooltip","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Attributes","title":"ApiDocMember.Attributes","content":"ApiDocMember.Attributes \nAttributes \n The declared attributes of the member","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#UrlBaseName","title":"ApiDocMember.UrlBaseName","content":"ApiDocMember.UrlBaseName \nUrlBaseName \n The URL base name of the best link documentation for the item (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#CategoryIndex","title":"ApiDocMember.CategoryIndex","content":"ApiDocMember.CategoryIndex \nCategoryIndex \n The category index","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#ObsoleteMessage","title":"ApiDocMember.ObsoleteMessage","content":"ApiDocMember.ObsoleteMessage \nObsoleteMessage \n Returns the obsolete message, when this member is obsolete. When its not or no message was specified, an empty string is returned","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Exclude","title":"ApiDocMember.Exclude","content":"ApiDocMember.Exclude \nExclude \n The exclude flag","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#IsRequireQualifiedAccessAttribute","title":"ApiDocMember.IsRequireQualifiedAccessAttribute","content":"ApiDocMember.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Symbol","title":"ApiDocMember.Symbol","content":"ApiDocMember.Symbol \nSymbol \n The symbol this member is related to","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#TypeArguments","title":"ApiDocMember.TypeArguments","content":"ApiDocMember.TypeArguments \nTypeArguments \n The member\u0027s type arguments","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#FormatModifiers","title":"ApiDocMember.FormatModifiers","content":"ApiDocMember.FormatModifiers \nFormatModifiers \n Formats modifiers","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#CustomOperationName","title":"ApiDocMember.CustomOperationName","content":"ApiDocMember.CustomOperationName \nCustomOperationName \n Returns the custom operation name, when this attribute is the CustomOperationAttribute.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#CompiledName","title":"ApiDocMember.CompiledName","content":"ApiDocMember.CompiledName \nCompiledName \n The member\u0027s compiled name, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Parameters","title":"ApiDocMember.Parameters","content":"ApiDocMember.Parameters \nParameters \n The member\u0027s parameters and associated documentation","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#IsObsolete","title":"ApiDocMember.IsObsolete","content":"ApiDocMember.IsObsolete \nIsObsolete \n Gets a value indicating whether this member is obsolete","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Comment","title":"ApiDocMember.Comment","content":"ApiDocMember.Comment \nComment \n The attached comment","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Category","title":"ApiDocMember.Category","content":"ApiDocMember.Category \nCategory \n The category","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#GetUrl","title":"ApiDocMember.GetUrl","content":"ApiDocMember.GetUrl \nGetUrl \n The URL of the best link documentation for the item relative to \u0022reference\u0022 directory (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberdetails.html","title":"ApiDocMemberDetails","content":"ApiDocMemberDetails \n \nApiDocMemberDetails.ApiDocMemberDetails \nApiDocMemberDetails","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberdetails.html#ApiDocMemberDetails","title":"ApiDocMemberDetails.ApiDocMemberDetails","content":"ApiDocMemberDetails.ApiDocMemberDetails \nApiDocMemberDetails \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html","title":"ApiDocMemberKind","content":"ApiDocMemberKind \n Represents the kind of member \nApiDocMemberKind.ValueOrFunction \nValueOrFunction \nApiDocMemberKind.TypeExtension \nTypeExtension \nApiDocMemberKind.ActivePattern \nActivePattern \nApiDocMemberKind.Constructor \nConstructor \nApiDocMemberKind.InstanceMember \nInstanceMember \nApiDocMemberKind.StaticMember \nStaticMember \nApiDocMemberKind.UnionCase \nUnionCase \nApiDocMemberKind.RecordField \nRecordField \nApiDocMemberKind.StaticParameter \nStaticParameter","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#ValueOrFunction","title":"ApiDocMemberKind.ValueOrFunction","content":"ApiDocMemberKind.ValueOrFunction \nValueOrFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#TypeExtension","title":"ApiDocMemberKind.TypeExtension","content":"ApiDocMemberKind.TypeExtension \nTypeExtension \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#ActivePattern","title":"ApiDocMemberKind.ActivePattern","content":"ApiDocMemberKind.ActivePattern \nActivePattern \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#Constructor","title":"ApiDocMemberKind.Constructor","content":"ApiDocMemberKind.Constructor \nConstructor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#InstanceMember","title":"ApiDocMemberKind.InstanceMember","content":"ApiDocMemberKind.InstanceMember \nInstanceMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#StaticMember","title":"ApiDocMemberKind.StaticMember","content":"ApiDocMemberKind.StaticMember \nStaticMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#UnionCase","title":"ApiDocMemberKind.UnionCase","content":"ApiDocMemberKind.UnionCase \nUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#RecordField","title":"ApiDocMemberKind.RecordField","content":"ApiDocMemberKind.RecordField \nRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#StaticParameter","title":"ApiDocMemberKind.StaticParameter","content":"ApiDocMemberKind.StaticParameter \nStaticParameter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html","title":"ApiDocModel","content":"ApiDocModel \n Represents a set of assemblies integrated with their associated documentation \nApiDocModel.IndexFileUrl \nIndexFileUrl \nApiDocModel.IndexOutputFile \nIndexOutputFile \nApiDocModel.Collection \nCollection \nApiDocModel.FileExtensions \nFileExtensions \nApiDocModel.Substitutions \nSubstitutions \nApiDocModel.EntityInfos \nEntityInfos \nApiDocModel.Qualify \nQualify \nApiDocModel.Root \nRoot","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#IndexFileUrl","title":"ApiDocModel.IndexFileUrl","content":"ApiDocModel.IndexFileUrl \nIndexFileUrl \n URL of the \u0027index.html\u0027 for the reference documentation for the model","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#IndexOutputFile","title":"ApiDocModel.IndexOutputFile","content":"ApiDocModel.IndexOutputFile \nIndexOutputFile \n URL of the \u0027index.html\u0027 for the reference documentation for the model","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Collection","title":"ApiDocModel.Collection","content":"ApiDocModel.Collection \nCollection \n The full list of all entities","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#FileExtensions","title":"ApiDocModel.FileExtensions","content":"ApiDocModel.FileExtensions \nFileExtensions \n Specifies file extensions to use in files and URLs","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Substitutions","title":"ApiDocModel.Substitutions","content":"ApiDocModel.Substitutions \nSubstitutions \n The substitutions. Different substitutions can also be used for each specific input","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#EntityInfos","title":"ApiDocModel.EntityInfos","content":"ApiDocModel.EntityInfos \nEntityInfos \n The full list of all entities","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Qualify","title":"ApiDocModel.Qualify","content":"ApiDocModel.Qualify \nQualify \n Indicates if each collection is being qualified by its collection name, e.g. \u0027reference/FSharp.Core\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Root","title":"ApiDocModel.Root","content":"ApiDocModel.Root \nRoot \n The root URL for the entire generation, normally \u0027/\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html","title":"ApiDocNamespace","content":"ApiDocNamespace \n Represents a namespace integrated with its associated documentation \nApiDocNamespace.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocNamespace.OutputFile \nOutputFile \nApiDocNamespace.Url \nUrl \nApiDocNamespace.UrlHash \nUrlHash \nApiDocNamespace.Name \nName \nApiDocNamespace.UrlBaseName \nUrlBaseName \nApiDocNamespace.NamespaceDocs \nNamespaceDocs \nApiDocNamespace.Entities \nEntities \nApiDocNamespace.Substitutions \nSubstitutions","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#\u0060\u0060.ctor\u0060\u0060","title":"ApiDocNamespace.\u0060\u0060.ctor\u0060\u0060","content":"ApiDocNamespace.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#OutputFile","title":"ApiDocNamespace.OutputFile","content":"ApiDocNamespace.OutputFile \nOutputFile \n The name of the file generated for this entity","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Url","title":"ApiDocNamespace.Url","content":"ApiDocNamespace.Url \nUrl \n The URL of the best link documentation for the item (without the http://site.io/reference)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#UrlHash","title":"ApiDocNamespace.UrlHash","content":"ApiDocNamespace.UrlHash \nUrlHash \n The hash label for the URL with the overall namespaces file","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Name","title":"ApiDocNamespace.Name","content":"ApiDocNamespace.Name \nName \n The name of the namespace","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#UrlBaseName","title":"ApiDocNamespace.UrlBaseName","content":"ApiDocNamespace.UrlBaseName \nUrlBaseName \n The base name for the generated file","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#NamespaceDocs","title":"ApiDocNamespace.NamespaceDocs","content":"ApiDocNamespace.NamespaceDocs \nNamespaceDocs \n The summary text for the namespace","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Entities","title":"ApiDocNamespace.Entities","content":"ApiDocNamespace.Entities \nEntities \n All modules in the namespace","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Substitutions","title":"ApiDocNamespace.Substitutions","content":"ApiDocNamespace.Substitutions \nSubstitutions \n The substitution substitutions active for generating thist content","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoctype.html","title":"ApiDocType","content":"ApiDocType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html","title":"ApiDocs","content":"ApiDocs \n\n This type exposes the functionality for producing documentation model from \u0060dll\u0060 files with associated \u0060xml\u0060 files\n generated by the F# or C# compiler. To generate documentation model, use one of the overloades of the \u0060Generate\u0060 method.\n \nApiDocs.GenerateHtml \nGenerateHtml \nApiDocs.GenerateMarkdown \nGenerateMarkdown \nApiDocs.GenerateModel \nGenerateModel \nApiDocs.SearchIndexEntriesForModel \nSearchIndexEntriesForModel","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#GenerateHtml","title":"ApiDocs.GenerateHtml","content":"ApiDocs.GenerateHtml \nGenerateHtml \n\n Generates default HTML pages for the assemblies specified by the \u0060inputs\u0060 parameter\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#GenerateMarkdown","title":"ApiDocs.GenerateMarkdown","content":"ApiDocs.GenerateMarkdown \nGenerateMarkdown \n\n Generates default Markdown pages for the assemblies specified by the \u0060inputs\u0060 parameter\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#GenerateModel","title":"ApiDocs.GenerateModel","content":"ApiDocs.GenerateModel \nGenerateModel \n\n Generates a documentation model for the assemblies specified by the \u0060inputs\u0060 parameter\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#SearchIndexEntriesForModel","title":"ApiDocs.SearchIndexEntriesForModel","content":"ApiDocs.SearchIndexEntriesForModel \nSearchIndexEntriesForModel \n\n Generates the search index from the given documentation model\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html","title":"ApiDocsSearchIndexEntry","content":"ApiDocsSearchIndexEntry \n Represents an entry suitable for constructing a Lunr index \nApiDocsSearchIndexEntry.uri \nuri \nApiDocsSearchIndexEntry.title \ntitle \nApiDocsSearchIndexEntry.content \ncontent \nApiDocsSearchIndexEntry.headings \nheadings \nApiDocsSearchIndexEntry.type \ntype","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#uri","title":"ApiDocsSearchIndexEntry.uri","content":"ApiDocsSearchIndexEntry.uri \nuri \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#title","title":"ApiDocsSearchIndexEntry.title","content":"ApiDocsSearchIndexEntry.title \ntitle \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#content","title":"ApiDocsSearchIndexEntry.content","content":"ApiDocsSearchIndexEntry.content \ncontent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#headings","title":"ApiDocsSearchIndexEntry.headings","content":"ApiDocsSearchIndexEntry.headings \nheadings \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#type","title":"ApiDocsSearchIndexEntry.type","content":"ApiDocsSearchIndexEntry.type \ntype \n apiDocs or content","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-attribute.html","title":"Attribute","content":"Attribute \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-doccomment.html","title":"DocComment","content":"DocComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-member.html","title":"Member","content":"Member \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-memberkind.html","title":"MemberKind","content":"MemberKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-module.html","title":"Module","content":"Module \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-moduleinfo.html","title":"ModuleInfo","content":"ModuleInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-type.html","title":"Type","content":"Type \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-typeinfo.html","title":"TypeInfo","content":"TypeInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-clikeformat.html","title":"CLikeFormat","content":"CLikeFormat \n\n Provides a base class for formatting languages similar to C.\n \nCLikeFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCLikeFormat.CommentRegEx \nCommentRegEx \nCLikeFormat.StringRegEx \nStringRegEx","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-clikeformat.html#\u0060\u0060.ctor\u0060\u0060","title":"CLikeFormat.\u0060\u0060.ctor\u0060\u0060","content":"CLikeFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-clikeformat.html#CommentRegEx","title":"CLikeFormat.CommentRegEx","content":"CLikeFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match single line and multi-line \n comments (// and /* */).","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-clikeformat.html#StringRegEx","title":"CLikeFormat.StringRegEx","content":"CLikeFormat.StringRegEx \nStringRegEx \n Regular expression string to match string and character literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html","title":"CPlusPlusFormat","content":"CPlusPlusFormat \n Generates color-coded HTML 4.01 from C\u002B\u002B source code. \nCPlusPlusFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCPlusPlusFormat.Keywords \nKeywords \nCPlusPlusFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html#\u0060\u0060.ctor\u0060\u0060","title":"CPlusPlusFormat.\u0060\u0060.ctor\u0060\u0060","content":"CPlusPlusFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html#Keywords","title":"CPlusPlusFormat.Keywords","content":"CPlusPlusFormat.Keywords \nKeywords \n The list of C\u002B\u002B keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html#Preprocessors","title":"CPlusPlusFormat.Preprocessors","content":"CPlusPlusFormat.Preprocessors \nPreprocessors \n The list of C\u002B\u002B preprocessors.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html","title":"CSharpFormat","content":"CSharpFormat \n Generates color-coded HTML 4.01 from C# source code. \nCSharpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCSharpFormat.Keywords \nKeywords \nCSharpFormat.Preprocessors \nPreprocessors \nCSharpFormat.Operators \nOperators","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#\u0060\u0060.ctor\u0060\u0060","title":"CSharpFormat.\u0060\u0060.ctor\u0060\u0060","content":"CSharpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#Keywords","title":"CSharpFormat.Keywords","content":"CSharpFormat.Keywords \nKeywords \n The list of C# keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#Preprocessors","title":"CSharpFormat.Preprocessors","content":"CSharpFormat.Preprocessors \nPreprocessors \n The list of C# preprocessors.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#Operators","title":"CSharpFormat.Operators","content":"CSharpFormat.Operators \nOperators \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html","title":"CodeFormat","content":"CodeFormat \n Provides a base class for formatting most programming languages. \nCodeFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCodeFormat.Keywords \nKeywords \nCodeFormat.Operators \nOperators \nCodeFormat.Preprocessors \nPreprocessors \nCodeFormat.StringRegEx \nStringRegEx \nCodeFormat.CommentRegEx \nCommentRegEx \nCodeFormat.NumberRegEx \nNumberRegEx \nCodeFormat.CaseSensitive \nCaseSensitive","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#\u0060\u0060.ctor\u0060\u0060","title":"CodeFormat.\u0060\u0060.ctor\u0060\u0060","content":"CodeFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n\u003Cpre\u003E\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#Keywords","title":"CodeFormat.Keywords","content":"CodeFormat.Keywords \nKeywords \n\n Must be overridden to provide a list of keywords defined in \n each language.\n \n\n Keywords must be separated with spaces.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#Operators","title":"CodeFormat.Operators","content":"CodeFormat.Operators \nOperators \n\n Must be overridden to provide a list of operators defined in \n each language.\n \n\n Operators must be separated with spaces.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#Preprocessors","title":"CodeFormat.Preprocessors","content":"CodeFormat.Preprocessors \nPreprocessors \n\n Can be overridden to provide a list of preprocessors defined in \n each language.\n \n\n Preprocessors must be separated with spaces.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#StringRegEx","title":"CodeFormat.StringRegEx","content":"CodeFormat.StringRegEx \nStringRegEx \n Must be overridden to provide a regular expression string\n to match strings literals.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#CommentRegEx","title":"CodeFormat.CommentRegEx","content":"CodeFormat.CommentRegEx \nCommentRegEx \n Must be overridden to provide a regular expression string\n to match comments.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#NumberRegEx","title":"CodeFormat.NumberRegEx","content":"CodeFormat.NumberRegEx \nNumberRegEx \n Can be overridden to provide a list of tokes to be recognized as numbers.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#CaseSensitive","title":"CodeFormat.CaseSensitive","content":"CodeFormat.CaseSensitive \nCaseSensitive \n\n Determines if the language is case sensitive.\n \n\n A case-insensitive language formatter must override this \n property to return false.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html","title":"FSharpFormat","content":"FSharpFormat \n Generates color-coded HTML 4.01 from F# source code. \nFSharpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFSharpFormat.Operators \nOperators \nFSharpFormat.CommentRegEx \nCommentRegEx \nFSharpFormat.Keywords \nKeywords \nFSharpFormat.StringRegEx \nStringRegEx \nFSharpFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#\u0060\u0060.ctor\u0060\u0060","title":"FSharpFormat.\u0060\u0060.ctor\u0060\u0060","content":"FSharpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#Operators","title":"FSharpFormat.Operators","content":"FSharpFormat.Operators \nOperators \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#CommentRegEx","title":"FSharpFormat.CommentRegEx","content":"FSharpFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match single line and multi-line \n comments (// and (* *)).","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#Keywords","title":"FSharpFormat.Keywords","content":"FSharpFormat.Keywords \nKeywords \n The list of F# keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#StringRegEx","title":"FSharpFormat.StringRegEx","content":"FSharpFormat.StringRegEx \nStringRegEx \n Regular expression string to match string and character literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#Preprocessors","title":"FSharpFormat.Preprocessors","content":"FSharpFormat.Preprocessors \nPreprocessors \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html","title":"HaskellFormat","content":"HaskellFormat \n Generates color-coded HTML 4.01 from MSH (code name Monad) source code. \nHaskellFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nHaskellFormat.CommentRegEx \nCommentRegEx \nHaskellFormat.StringRegEx \nStringRegEx \nHaskellFormat.Keywords \nKeywords \nHaskellFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#\u0060\u0060.ctor\u0060\u0060","title":"HaskellFormat.\u0060\u0060.ctor\u0060\u0060","content":"HaskellFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#CommentRegEx","title":"HaskellFormat.CommentRegEx","content":"HaskellFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match single line comments (#).","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#StringRegEx","title":"HaskellFormat.StringRegEx","content":"HaskellFormat.StringRegEx \nStringRegEx \n Regular expression string to match string and character literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#Keywords","title":"HaskellFormat.Keywords","content":"HaskellFormat.Keywords \nKeywords \n The list of MSH keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#Preprocessors","title":"HaskellFormat.Preprocessors","content":"HaskellFormat.Preprocessors \nPreprocessors \n Use preprocessors property to hilight operators.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-htmlformat.html","title":"HtmlFormat","content":"HtmlFormat \n\n Generates color-coded HTML 4.01 from HTML/XML/ASPX source code.\n \n\u003Cp class=\u0027fsdocs-para\u0027\u003E\n This implementation assumes that code inside \u003Cscript\u003E blocks \n is JavaScript, and code inside \u003C% %\u003E blocks is C#.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\n The default tab width is set to 2 characters in this class.\u003C/p\u003E \nHtmlFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-htmlformat.html#\u0060\u0060.ctor\u0060\u0060","title":"HtmlFormat.\u0060\u0060.ctor\u0060\u0060","content":"HtmlFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n\u003Cpre\u003E\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html","title":"JavaScriptFormat","content":"JavaScriptFormat \n Generates color-coded HTML 4.01 from JavaSctript source code. \nJavaScriptFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nJavaScriptFormat.Keywords \nKeywords \nJavaScriptFormat.Preprocessors \nPreprocessors \nJavaScriptFormat.Operators \nOperators","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#\u0060\u0060.ctor\u0060\u0060","title":"JavaScriptFormat.\u0060\u0060.ctor\u0060\u0060","content":"JavaScriptFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#Keywords","title":"JavaScriptFormat.Keywords","content":"JavaScriptFormat.Keywords \nKeywords \n The list of JavaScript keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#Preprocessors","title":"JavaScriptFormat.Preprocessors","content":"JavaScriptFormat.Preprocessors \nPreprocessors \n Use the pre-processor color to mark directives that start with @.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#Operators","title":"JavaScriptFormat.Operators","content":"JavaScriptFormat.Operators \nOperators \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html","title":"MshFormat","content":"MshFormat \n Generates color-coded HTML 4.01 from MSH (code name Monad) source code. \nMshFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nMshFormat.CommentRegEx \nCommentRegEx \nMshFormat.StringRegEx \nStringRegEx \nMshFormat.Keywords \nKeywords \nMshFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#\u0060\u0060.ctor\u0060\u0060","title":"MshFormat.\u0060\u0060.ctor\u0060\u0060","content":"MshFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#CommentRegEx","title":"MshFormat.CommentRegEx","content":"MshFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match single line comments (#).","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#StringRegEx","title":"MshFormat.StringRegEx","content":"MshFormat.StringRegEx \nStringRegEx \n Regular expression string to match string and character literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#Keywords","title":"MshFormat.Keywords","content":"MshFormat.Keywords \nKeywords \n The list of MSH keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#Preprocessors","title":"MshFormat.Preprocessors","content":"MshFormat.Preprocessors \nPreprocessors \n Use preprocessors property to hilight operators.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html","title":"PaketFormat","content":"PaketFormat \n Generates color-coded Paket source code. \nPaketFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nPaketFormat.CommentRegEx \nCommentRegEx \nPaketFormat.Operators \nOperators \nPaketFormat.Keywords \nKeywords \nPaketFormat.NumberRegEx \nNumberRegEx","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#\u0060\u0060.ctor\u0060\u0060","title":"PaketFormat.\u0060\u0060.ctor\u0060\u0060","content":"PaketFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#CommentRegEx","title":"PaketFormat.CommentRegEx","content":"PaketFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match single line and multi-line \n comments (// and (* *)). Single line comments should have to have \n a space after them to avoid color as comments URLs and paths. For example","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#Operators","title":"PaketFormat.Operators","content":"PaketFormat.Operators \nOperators \n Paket operators","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#Keywords","title":"PaketFormat.Keywords","content":"PaketFormat.Keywords \nKeywords \n Paket Keywords","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#NumberRegEx","title":"PaketFormat.NumberRegEx","content":"PaketFormat.NumberRegEx \nNumberRegEx \n Matches version numbers","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html","title":"PhpFormat","content":"PhpFormat \n Generates color-coded HTML 4.01 from PHP source code. \nPhpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nPhpFormat.StringRegEx \nStringRegEx \nPhpFormat.Keywords \nKeywords \nPhpFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#\u0060\u0060.ctor\u0060\u0060","title":"PhpFormat.\u0060\u0060.ctor\u0060\u0060","content":"PhpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#StringRegEx","title":"PhpFormat.StringRegEx","content":"PhpFormat.StringRegEx \nStringRegEx \n Regular expression string to match string and character literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#Keywords","title":"PhpFormat.Keywords","content":"PhpFormat.Keywords \nKeywords \n The list of PHP keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#Preprocessors","title":"PhpFormat.Preprocessors","content":"PhpFormat.Preprocessors \nPreprocessors \n The list of PHP preprocessors.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html","title":"SourceFormat","content":"SourceFormat \n\n Provides a base implementation for all code formatters.\n \n\u003Cp class=\u0027fsdocs-para\u0027\u003E\n To display the formatted code on your web site, the web page must \n refer to a stylesheet that defines the formatting for the different \n CSS classes generated by CSharpFormat:\n .csharpcode, pre, .rem, .kwrd, .str, .op, .preproc, .alt, .lnum.\n \u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Note that if you have multi-line comments in your source code\n (like /* ... */), the \u0022line numbers\u0022 or \u0022alternate line background\u0022 \n options will generate code that is not strictly HTML 4.01 compliant. \n The code will still look good with IE5\u002B or Mozilla 0.8\u002B. \n \u003C/p\u003E \nSourceFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nSourceFormat.FormatCode \nFormatCode \nSourceFormat.FormatCode \nFormatCode \nSourceFormat.FormatSubCode \nFormatSubCode \nSourceFormat.TabSpaces \nTabSpaces \nSourceFormat.LineNumbers \nLineNumbers \nSourceFormat.Alternate \nAlternate \nSourceFormat.EmbedStyleSheet \nEmbedStyleSheet \nSourceFormat.CodeRegex \nCodeRegex \nSourceFormat.GetCssStream \nGetCssStream \nSourceFormat.GetCssString \nGetCssString \nSourceFormat.EscapeHtml \nEscapeHtml","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#\u0060\u0060.ctor\u0060\u0060","title":"SourceFormat.\u0060\u0060.ctor\u0060\u0060","content":"SourceFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n\u003Cpre\u003E\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#FormatCode","title":"SourceFormat.FormatCode","content":"SourceFormat.FormatCode \nFormatCode \n\n Transforms a source code stream to HTML 4.01.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#FormatCode","title":"SourceFormat.FormatCode","content":"SourceFormat.FormatCode \nFormatCode \n\n Transforms a source code string to HTML 4.01.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#FormatSubCode","title":"SourceFormat.FormatSubCode","content":"SourceFormat.FormatSubCode \nFormatSubCode \n Allows formatting a part of the code in a different language,\n for example a JavaScript block inside an HTML file.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#TabSpaces","title":"SourceFormat.TabSpaces","content":"SourceFormat.TabSpaces \nTabSpaces \n\n Gets or sets the tabs width.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#LineNumbers","title":"SourceFormat.LineNumbers","content":"SourceFormat.LineNumbers \nLineNumbers \n\n Enables or disables line numbers in output.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#Alternate","title":"SourceFormat.Alternate","content":"SourceFormat.Alternate \nAlternate \n\n Enables or disables alternating line background.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#EmbedStyleSheet","title":"SourceFormat.EmbedStyleSheet","content":"SourceFormat.EmbedStyleSheet \nEmbedStyleSheet \n\n Enables or disables the embedded CSS style sheet.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#CodeRegex","title":"SourceFormat.CodeRegex","content":"SourceFormat.CodeRegex \nCodeRegex \n The regular expression used to capture language tokens.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#GetCssStream","title":"SourceFormat.GetCssStream","content":"SourceFormat.GetCssStream \nGetCssStream \n\n Gets the CSS stylesheet as a stream.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#GetCssString","title":"SourceFormat.GetCssString","content":"SourceFormat.GetCssString \nGetCssString \n\n Gets the CSS stylesheet as a string.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#EscapeHtml","title":"SourceFormat.EscapeHtml","content":"SourceFormat.EscapeHtml \nEscapeHtml \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html","title":"SyntaxHighlighter","content":"SyntaxHighlighter \n Summary description for SyntaxHighlighter \nSyntaxHighlighter.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nSyntaxHighlighter.FormatHtml \nFormatHtml \nSyntaxHighlighter.FormatCode \nFormatCode","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html#\u0060\u0060.ctor\u0060\u0060","title":"SyntaxHighlighter.\u0060\u0060.ctor\u0060\u0060","content":"SyntaxHighlighter.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html#FormatHtml","title":"SyntaxHighlighter.FormatHtml","content":"SyntaxHighlighter.FormatHtml \nFormatHtml \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html#FormatCode","title":"SyntaxHighlighter.FormatCode","content":"SyntaxHighlighter.FormatCode \nFormatCode \n TBD","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html","title":"TsqlFormat","content":"TsqlFormat \n Generates color-coded T-SQL source code. \nTsqlFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTsqlFormat.CommentRegEx \nCommentRegEx \nTsqlFormat.StringRegEx \nStringRegEx \nTsqlFormat.CaseSensitive \nCaseSensitive \nTsqlFormat.Keywords \nKeywords \nTsqlFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#\u0060\u0060.ctor\u0060\u0060","title":"TsqlFormat.\u0060\u0060.ctor\u0060\u0060","content":"TsqlFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#CommentRegEx","title":"TsqlFormat.CommentRegEx","content":"TsqlFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match single line \n comments (--).","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#StringRegEx","title":"TsqlFormat.StringRegEx","content":"TsqlFormat.StringRegEx \nStringRegEx \n Regular expression string to match string literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#CaseSensitive","title":"TsqlFormat.CaseSensitive","content":"TsqlFormat.CaseSensitive \nCaseSensitive \n\n Returns \u003Cb\u003Efalse\u003C/b\u003E, since T-SQL is not case sensitive.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#Keywords","title":"TsqlFormat.Keywords","content":"TsqlFormat.Keywords \nKeywords \n The list of T-SQL keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#Preprocessors","title":"TsqlFormat.Preprocessors","content":"TsqlFormat.Preprocessors \nPreprocessors \n Use the pre-processor color to mark keywords that start with @@.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-typescriptformat.html","title":"TypeScriptFormat","content":"TypeScriptFormat \n Generates color-coded HTML 4.01 from TypeScript source code. \nTypeScriptFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTypeScriptFormat.Keywords \nKeywords","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-typescriptformat.html#\u0060\u0060.ctor\u0060\u0060","title":"TypeScriptFormat.\u0060\u0060.ctor\u0060\u0060","content":"TypeScriptFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-typescriptformat.html#Keywords","title":"TypeScriptFormat.Keywords","content":"TypeScriptFormat.Keywords \nKeywords \n The list of TypeScript keywords extends the ones from JavaScript.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html","title":"VisualBasicFormat","content":"VisualBasicFormat \n Generates color-coded HTML 4.01 from Visual Basic source code. \nVisualBasicFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nVisualBasicFormat.CaseSensitive \nCaseSensitive \nVisualBasicFormat.CommentRegEx \nCommentRegEx \nVisualBasicFormat.StringRegEx \nStringRegEx \nVisualBasicFormat.Keywords \nKeywords \nVisualBasicFormat.Preprocessors \nPreprocessors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#\u0060\u0060.ctor\u0060\u0060","title":"VisualBasicFormat.\u0060\u0060.ctor\u0060\u0060","content":"VisualBasicFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#CaseSensitive","title":"VisualBasicFormat.CaseSensitive","content":"VisualBasicFormat.CaseSensitive \nCaseSensitive \n\n Determines if the language is case sensitive.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#CommentRegEx","title":"VisualBasicFormat.CommentRegEx","content":"VisualBasicFormat.CommentRegEx \nCommentRegEx \n Regular expression string to match comments (\u0027 and REM). ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#StringRegEx","title":"VisualBasicFormat.StringRegEx","content":"VisualBasicFormat.StringRegEx \nStringRegEx \n Regular expression string to match string and character literals. ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#Keywords","title":"VisualBasicFormat.Keywords","content":"VisualBasicFormat.Keywords \nKeywords \n The list of VB keywords.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#Preprocessors","title":"VisualBasicFormat.Preprocessors","content":"VisualBasicFormat.Preprocessors \nPreprocessors \n The list of VB preprocessors.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html","title":"CodeFormatter","content":"CodeFormatter \n Uses agent to handle formatting requests \nCodeFormatter.processDoubleBackticks \nprocessDoubleBackticks \nCodeFormatter.categoryToTokenKind \ncategoryToTokenKind \nCodeFormatter.processSnippetLine \nprocessSnippetLine \nCodeFormatter.processSnippet \nprocessSnippet \nCodeFormatter.fsChecker \nfsChecker \nCodeFormatter.processSourceCode \nprocessSourceCode \nCodeFormatter.ParseAndCheckSource \nParseAndCheckSource","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processDoubleBackticks","title":"CodeFormatter.processDoubleBackticks","content":"CodeFormatter.processDoubleBackticks \nprocessDoubleBackticks \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#categoryToTokenKind","title":"CodeFormatter.categoryToTokenKind","content":"CodeFormatter.categoryToTokenKind \ncategoryToTokenKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processSnippetLine","title":"CodeFormatter.processSnippetLine","content":"CodeFormatter.processSnippetLine \nprocessSnippetLine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processSnippet","title":"CodeFormatter.processSnippet","content":"CodeFormatter.processSnippet \nprocessSnippet \n Process snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#fsChecker","title":"CodeFormatter.fsChecker","content":"CodeFormatter.fsChecker \nfsChecker \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processSourceCode","title":"CodeFormatter.processSourceCode","content":"CodeFormatter.processSourceCode \nprocessSourceCode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#ParseAndCheckSource","title":"CodeFormatter.ParseAndCheckSource","content":"CodeFormatter.ParseAndCheckSource \nParseAndCheckSource \n Parse, check and annotate the source code specified by \u0027source\u0027, assuming that it\n is located in a specified \u0027file\u0027. Optional arguments can be used\n to give compiler command line options and preprocessor definitions","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html","title":"CodeFormat","content":"CodeFormat \n Exposes functionality of the F# code formatter with a nice interface \nCodeFormat.FormatFsx \nFormatFsx \nCodeFormat.FormatHtml \nFormatHtml \nCodeFormat.FormatLatex \nFormatLatex","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatFsx","title":"CodeFormat.FormatFsx","content":"CodeFormat.FormatFsx \nFormatFsx \n Formats the .fsx snippets as iPython notebook using the default settings.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatHtml","title":"CodeFormat.FormatHtml","content":"CodeFormat.FormatHtml \nFormatHtml \n Formats the .fsx snippets as HTML. The parameters specify prefix for HTML tags, whether lines should\n be added to outputs and whether errors should be printed.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatLatex","title":"CodeFormat.FormatLatex","content":"CodeFormat.FormatLatex \nFormatLatex \n Formats the .fsx snippets as LaTeX. The parameters specify prefix for LaTeX tags, whether lines should\n be added to outputs.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-errorkind.html","title":"ErrorKind","content":"ErrorKind \n Represents a kind of error reported from the F# compiler (warning or error) \nErrorKind.Error \nError \nErrorKind.Warning \nWarning","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-errorkind.html#Error","title":"ErrorKind.Error","content":"ErrorKind.Error \nError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-errorkind.html#Warning","title":"ErrorKind.Warning","content":"ErrorKind.Warning \nWarning \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html","title":"FormattedContent","content":"FormattedContent \n Represents formatted snippets \nFormattedContent.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFormattedContent.ToolTip \nToolTip \nFormattedContent.Snippets \nSnippets","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html#\u0060\u0060.ctor\u0060\u0060","title":"FormattedContent.\u0060\u0060.ctor\u0060\u0060","content":"FormattedContent.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html#ToolTip","title":"FormattedContent.ToolTip","content":"FormattedContent.ToolTip \nToolTip \n Returns string with ToolTip elements for all the snippets","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html#Snippets","title":"FormattedContent.Snippets","content":"FormattedContent.Snippets \nSnippets \n Returns the processed snippets as an array","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html","title":"FormattedSnippet","content":"FormattedSnippet \n\n Represents an individual formatted snippet with title as key\n \nFormattedSnippet.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFormattedSnippet.Title \nTitle \nFormattedSnippet.Key \nKey \nFormattedSnippet.Content \nContent","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#\u0060\u0060.ctor\u0060\u0060","title":"FormattedSnippet.\u0060\u0060.ctor\u0060\u0060","content":"FormattedSnippet.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#Title","title":"FormattedSnippet.Title","content":"FormattedSnippet.Title \nTitle \n Returns the title of the snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#Key","title":"FormattedSnippet.Key","content":"FormattedSnippet.Key \nKey \n Returns the key of the snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#Content","title":"FormattedSnippet.Content","content":"FormattedSnippet.Content \nContent \n Returns the formatted content code for the snipet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-line.html","title":"Line","content":"Line \n Represents a line of source code as a list of TokenSpan values. This is\n a single case discriminated union with Line constructor. \nLine.Line \nLine","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-line.html#Line","title":"Line.Line","content":"Line.Line \nLine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-snippet.html","title":"Snippet","content":"Snippet \n An F# snippet consists of a snippet title and a list of lines \nSnippet.Snippet \nSnippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-snippet.html#Snippet","title":"Snippet.Snippet","content":"Snippet.Snippet \nSnippet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-sourceerror.html","title":"SourceError","content":"SourceError \n Error reported from the F# compiler consists of location (start and end),\n error kind and the message (wrapped in a single case discriminated union\n with constructor SourceError) \nSourceError.SourceError \nSourceError","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-sourceerror.html#SourceError","title":"SourceError.SourceError","content":"SourceError.SourceError \nSourceError \n Error reported from the F# compiler consists of location (start and end),\n error kind and the message","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html","title":"TokenKind","content":"TokenKind \n Classifies tokens reported by the FCS \nTokenKind.Keyword \nKeyword \nTokenKind.String \nString \nTokenKind.Comment \nComment \nTokenKind.Identifier \nIdentifier \nTokenKind.Inactive \nInactive \nTokenKind.Number \nNumber \nTokenKind.Operator \nOperator \nTokenKind.Punctuation \nPunctuation \nTokenKind.Preprocessor \nPreprocessor \nTokenKind.Module \nModule \nTokenKind.ReferenceType \nReferenceType \nTokenKind.ValueType \nValueType \nTokenKind.Interface \nInterface \nTokenKind.TypeArgument \nTypeArgument \nTokenKind.Property \nProperty \nTokenKind.Enumeration \nEnumeration \nTokenKind.UnionCase \nUnionCase \nTokenKind.Function \nFunction \nTokenKind.Pattern \nPattern \nTokenKind.MutableVar \nMutableVar \nTokenKind.Disposable \nDisposable \nTokenKind.Printf \nPrintf \nTokenKind.Escaped \nEscaped \nTokenKind.Default \nDefault","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Keyword","title":"TokenKind.Keyword","content":"TokenKind.Keyword \nKeyword \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#String","title":"TokenKind.String","content":"TokenKind.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Comment","title":"TokenKind.Comment","content":"TokenKind.Comment \nComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Identifier","title":"TokenKind.Identifier","content":"TokenKind.Identifier \nIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Inactive","title":"TokenKind.Inactive","content":"TokenKind.Inactive \nInactive \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Number","title":"TokenKind.Number","content":"TokenKind.Number \nNumber \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Operator","title":"TokenKind.Operator","content":"TokenKind.Operator \nOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Punctuation","title":"TokenKind.Punctuation","content":"TokenKind.Punctuation \nPunctuation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Preprocessor","title":"TokenKind.Preprocessor","content":"TokenKind.Preprocessor \nPreprocessor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Module","title":"TokenKind.Module","content":"TokenKind.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#ReferenceType","title":"TokenKind.ReferenceType","content":"TokenKind.ReferenceType \nReferenceType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#ValueType","title":"TokenKind.ValueType","content":"TokenKind.ValueType \nValueType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Interface","title":"TokenKind.Interface","content":"TokenKind.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#TypeArgument","title":"TokenKind.TypeArgument","content":"TokenKind.TypeArgument \nTypeArgument \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Property","title":"TokenKind.Property","content":"TokenKind.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Enumeration","title":"TokenKind.Enumeration","content":"TokenKind.Enumeration \nEnumeration \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#UnionCase","title":"TokenKind.UnionCase","content":"TokenKind.UnionCase \nUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Function","title":"TokenKind.Function","content":"TokenKind.Function \nFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Pattern","title":"TokenKind.Pattern","content":"TokenKind.Pattern \nPattern \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#MutableVar","title":"TokenKind.MutableVar","content":"TokenKind.MutableVar \nMutableVar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Disposable","title":"TokenKind.Disposable","content":"TokenKind.Disposable \nDisposable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Printf","title":"TokenKind.Printf","content":"TokenKind.Printf \nPrintf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Escaped","title":"TokenKind.Escaped","content":"TokenKind.Escaped \nEscaped \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Default","title":"TokenKind.Default","content":"TokenKind.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html","title":"TokenSpan","content":"TokenSpan \n A token in a parsed F# code snippet. Aside from standard tokens reported from\n the compiler (Token), this also includes Error (wrapping the underlined\n tokens), Omitted for the special [omit:...] tags and Output for the special [output:...] tag \nTokenSpan.Token \nToken \nTokenSpan.Error \nError \nTokenSpan.Omitted \nOmitted \nTokenSpan.Output \nOutput","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Token","title":"TokenSpan.Token","content":"TokenSpan.Token \nToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Error","title":"TokenSpan.Error","content":"TokenSpan.Error \nError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Omitted","title":"TokenSpan.Omitted","content":"TokenSpan.Omitted \nOmitted \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Output","title":"TokenSpan.Output","content":"TokenSpan.Output \nOutput \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html","title":"TokenSpans","content":"TokenSpans \n A type alias representing a list of TokenSpan values \nTokenSpans.Head \nHead \nTokenSpans.Item \nItem \nTokenSpans.Tail \nTail \nTokenSpans.IsEmpty \nIsEmpty \nTokenSpans.Length \nLength \nTokenSpans.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Head","title":"TokenSpans.Head","content":"TokenSpans.Head \nHead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Item","title":"TokenSpans.Item","content":"TokenSpans.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Tail","title":"TokenSpans.Tail","content":"TokenSpans.Tail \nTail \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#IsEmpty","title":"TokenSpans.IsEmpty","content":"TokenSpans.IsEmpty \nIsEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Length","title":"TokenSpans.Length","content":"TokenSpans.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Empty","title":"TokenSpans.Empty","content":"TokenSpans.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html","title":"ToolTipSpan","content":"ToolTipSpan \n A tool tip span can be emphasized text, plain text Literal or a line brak \nToolTipSpan.Emphasis \nEmphasis \nToolTipSpan.Literal \nLiteral \nToolTipSpan.HardLineBreak \nHardLineBreak","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html#Emphasis","title":"ToolTipSpan.Emphasis","content":"ToolTipSpan.Emphasis \nEmphasis \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html#Literal","title":"ToolTipSpan.Literal","content":"ToolTipSpan.Literal \nLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html#HardLineBreak","title":"ToolTipSpan.HardLineBreak","content":"ToolTipSpan.HardLineBreak \nHardLineBreak \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html","title":"ToolTipSpans","content":"ToolTipSpans \n A tool tip consists of a list of items reported from the compiler \nToolTipSpans.Head \nHead \nToolTipSpans.Item \nItem \nToolTipSpans.Tail \nTail \nToolTipSpans.IsEmpty \nIsEmpty \nToolTipSpans.Length \nLength \nToolTipSpans.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Head","title":"ToolTipSpans.Head","content":"ToolTipSpans.Head \nHead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Item","title":"ToolTipSpans.Item","content":"ToolTipSpans.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Tail","title":"ToolTipSpans.Tail","content":"ToolTipSpans.Tail \nTail \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#IsEmpty","title":"ToolTipSpans.IsEmpty","content":"ToolTipSpans.IsEmpty \nIsEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Length","title":"ToolTipSpans.Length","content":"ToolTipSpans.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Empty","title":"ToolTipSpans.Empty","content":"ToolTipSpans.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html","title":"Menu","content":"Menu \n \nMenu.MenuItem \nMenuItem \nMenu.createMenu \ncreateMenu \nMenu.isTemplatingAvailable \nisTemplatingAvailable \nMenu.getLastWriteTimes \ngetLastWriteTimes","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html#createMenu","title":"Menu.createMenu","content":"Menu.createMenu \ncreateMenu \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html#isTemplatingAvailable","title":"Menu.isTemplatingAvailable","content":"Menu.isTemplatingAvailable \nisTemplatingAvailable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html#getLastWriteTimes","title":"Menu.getLastWriteTimes","content":"Menu.getLastWriteTimes \ngetLastWriteTimes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu-menuitem.html","title":"MenuItem","content":"MenuItem \n \nMenuItem.Link \nLink \nMenuItem.Content \nContent \nMenuItem.IsActive \nIsActive","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu-menuitem.html#Link","title":"MenuItem.Link","content":"MenuItem.Link \nLink \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu-menuitem.html#Content","title":"MenuItem.Content","content":"MenuItem.Content \nContent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu-menuitem.html#IsActive","title":"MenuItem.IsActive","content":"MenuItem.IsActive \nIsActive \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-pagecontentlist.html","title":"PageContentList","content":"PageContentList \n \nPageContentList.EmptyContent \nEmptyContent \nPageContentList.mkPageContentMenu \nmkPageContentMenu","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-pagecontentlist.html#EmptyContent","title":"PageContentList.EmptyContent","content":"PageContentList.EmptyContent \nEmptyContent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-pagecontentlist.html#mkPageContentMenu","title":"PageContentList.mkPageContentMenu","content":"PageContentList.mkPageContentMenu \nmkPageContentMenu \n We process the html to collect the table of content.\n We can\u0027t use the doc.MarkdownDocument because we cannot easily get the generated id values.\n It is safer to parse the html.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-markdownpatterns.html","title":"MarkdownPatterns","content":"MarkdownPatterns \n\n Provides active patterns for extracting \u003Ccode\u003ELiterateParagraph\u003C/code\u003E values from\n Markdown documents.\n \nMarkdownPatterns.(|LiterateParagraph|_|) \n(|LiterateParagraph|_|)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-markdownpatterns.html#(|LiterateParagraph|_|)","title":"MarkdownPatterns.(|LiterateParagraph|_|)","content":"MarkdownPatterns.(|LiterateParagraph|_|) \n(|LiterateParagraph|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-indextext.html","title":"IndexText","content":"IndexText \n \nIndexText.IndexText \nIndexText","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-indextext.html#IndexText","title":"IndexText.IndexText","content":"IndexText.IndexText \nIndexText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html","title":"Literate","content":"Literate \n\n This type provides three simple methods for calling the literate programming tool.\n The \u003Ccode\u003EConvertMarkdownFile\u003C/code\u003E and \u003Ccode\u003EConvertScriptFile\u003C/code\u003E methods process a single Markdown document\n and F# script, respectively. The \u003Ccode\u003EConvertDirectory\u003C/code\u003E method handles an entire directory tree\n (looking for \u003Ccode\u003E*.fsx\u003C/code\u003E and \u003Ccode\u003E*.md\u003C/code\u003E files).\n \nLiterate.ConvertMarkdownFile \nConvertMarkdownFile \nLiterate.ConvertScriptFile \nConvertScriptFile \nLiterate.ParseAndCheckScriptFile \nParseAndCheckScriptFile \nLiterate.ParseMarkdownFile \nParseMarkdownFile \nLiterate.ParseMarkdownString \nParseMarkdownString \nLiterate.ParsePynbString \nParsePynbString \nLiterate.ParseScriptString \nParseScriptString \nLiterate.ToFsx \nToFsx \nLiterate.ToHtml \nToHtml \nLiterate.ToLatex \nToLatex \nLiterate.ToPynb \nToPynb \nLiterate.WriteHtml \nWriteHtml \nLiterate.WriteLatex \nWriteLatex","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertMarkdownFile","title":"Literate.ConvertMarkdownFile","content":"Literate.ConvertMarkdownFile \nConvertMarkdownFile \n Convert a markdown file into HTML or another output kind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertScriptFile","title":"Literate.ConvertScriptFile","content":"Literate.ConvertScriptFile \nConvertScriptFile \nConvert a script file into HTML or another output kind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParseAndCheckScriptFile","title":"Literate.ParseAndCheckScriptFile","content":"Literate.ParseAndCheckScriptFile \nParseAndCheckScriptFile \n Parse F# Script file to LiterateDocument","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParseMarkdownFile","title":"Literate.ParseMarkdownFile","content":"Literate.ParseMarkdownFile \nParseMarkdownFile \n\n Parse Markdown document to LiterateDocument\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParseMarkdownString","title":"Literate.ParseMarkdownString","content":"Literate.ParseMarkdownString \nParseMarkdownString \n\n Parse string as a markdown document\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParsePynbString","title":"Literate.ParsePynbString","content":"Literate.ParsePynbString \nParsePynbString \n\n Parse pynb string as literate document\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParseScriptString","title":"Literate.ParseScriptString","content":"Literate.ParseScriptString \nParseScriptString \n Parse string as F# Script to LiterateDocument","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToFsx","title":"Literate.ToFsx","content":"Literate.ToFsx \nToFsx \n Formate the literate document as an .fsx script","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToHtml","title":"Literate.ToHtml","content":"Literate.ToHtml \nToHtml \n Format the literate document as HTML without using a template","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToLatex","title":"Literate.ToLatex","content":"Literate.ToLatex \nToLatex \n Format the literate document as Latex without using a template","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToPynb","title":"Literate.ToPynb","content":"Literate.ToPynb \nToPynb \n Formate the literate document as an iPython notebook","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#WriteHtml","title":"Literate.WriteHtml","content":"Literate.WriteHtml \nWriteHtml \n Write the literate document as HTML without using a template","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#WriteLatex","title":"Literate.WriteLatex","content":"Literate.WriteLatex \nWriteLatex \n Write the literate document as Latex without using a template","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html","title":"LiterateCodeOptions","content":"LiterateCodeOptions \n\n Additional properties of a literate code snippet, embedded in a\n \u003Ccode\u003ELiterateParagraph.LiterateCode\u003C/code\u003E. The properties specify how should\n a snippet be evaluated and formatted.\n \nLiterateCodeOptions.Evaluate \nEvaluate \nLiterateCodeOptions.OutputName \nOutputName \nLiterateCodeOptions.ExecutionCount \nExecutionCount \nLiterateCodeOptions.Visibility \nVisibility","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#Evaluate","title":"LiterateCodeOptions.Evaluate","content":"LiterateCodeOptions.Evaluate \nEvaluate \n\n Specifies whether the snippet is evalauted while processing\n Use (*** do-not-eval ***) command to set this to \u003Ccode\u003Efalse\u003C/code\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#OutputName","title":"LiterateCodeOptions.OutputName","content":"LiterateCodeOptions.OutputName \nOutputName \n Specifies the name of the output produced by this snippet\n Use the (*** define-output:foo ***) command to set this value\n Other outputs are named cell1, cell2 etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#ExecutionCount","title":"LiterateCodeOptions.ExecutionCount","content":"LiterateCodeOptions.ExecutionCount \nExecutionCount \n Indiciates the execution sequence number of the cell if it has been evaluated","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#Visibility","title":"LiterateCodeOptions.Visibility","content":"LiterateCodeOptions.Visibility \nVisibility \n Specifies the visibility of the snippet in the generated HTML","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html","title":"LiterateCodeVisibility","content":"LiterateCodeVisibility \n Specifies visibility of a code snippet. \nLiterateCodeVisibility.VisibleCode \nVisibleCode \nLiterateCodeVisibility.HiddenCode \nHiddenCode \nLiterateCodeVisibility.NamedCode \nNamedCode","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html#VisibleCode","title":"LiterateCodeVisibility.VisibleCode","content":"LiterateCodeVisibility.VisibleCode \nVisibleCode \n Ordinary visible code","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html#HiddenCode","title":"LiterateCodeVisibility.HiddenCode","content":"LiterateCodeVisibility.HiddenCode \nHiddenCode \n Hidden snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html#NamedCode","title":"LiterateCodeVisibility.NamedCode","content":"LiterateCodeVisibility.NamedCode \nNamedCode \n Named snippet with captured output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html","title":"LiterateDocument","content":"LiterateDocument \n Representation of a literate document - the representation of Paragraphs\n uses an F# discriminated union type and so is best used from F#. \nLiterateDocument.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nLiterateDocument.With \nWith \nLiterateDocument.MarkdownDocument \nMarkdownDocument \nLiterateDocument.Paragraphs \nParagraphs \nLiterateDocument.SourceFile \nSourceFile \nLiterateDocument.RootInputFolder \nRootInputFolder \nLiterateDocument.FormattedTips \nFormattedTips \nLiterateDocument.Source \nSource \nLiterateDocument.Diagnostics \nDiagnostics \nLiterateDocument.DefinedLinks \nDefinedLinks","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#\u0060\u0060.ctor\u0060\u0060","title":"LiterateDocument.\u0060\u0060.ctor\u0060\u0060","content":"LiterateDocument.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#With","title":"LiterateDocument.With","content":"LiterateDocument.With \nWith \n Clone the document and change some of its properties","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#MarkdownDocument","title":"LiterateDocument.MarkdownDocument","content":"LiterateDocument.MarkdownDocument \nMarkdownDocument \n Return as markdown document, throwing away additional stuff","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#Paragraphs","title":"LiterateDocument.Paragraphs","content":"LiterateDocument.Paragraphs \nParagraphs \n Returns a list of paragraphs in the document","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#SourceFile","title":"LiterateDocument.SourceFile","content":"LiterateDocument.SourceFile \nSourceFile \n Location where the file was loaded from","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#RootInputFolder","title":"LiterateDocument.RootInputFolder","content":"LiterateDocument.RootInputFolder \nRootInputFolder \n Root for computing relative paths","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#FormattedTips","title":"LiterateDocument.FormattedTips","content":"LiterateDocument.FormattedTips \nFormattedTips \n Formatted tool tips","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#Source","title":"LiterateDocument.Source","content":"LiterateDocument.Source \nSource \n Original document source code","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#Diagnostics","title":"LiterateDocument.Diagnostics","content":"LiterateDocument.Diagnostics \nDiagnostics \n Errors","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#DefinedLinks","title":"LiterateDocument.DefinedLinks","content":"LiterateDocument.DefinedLinks \nDefinedLinks \n Returns a dictionary containing explicitly defined links","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html","title":"LiterateParagraph","content":"LiterateParagraph \n\n Extends \u003Ccode\u003EMarkdownParagrap\u003C/code\u003E using the \u003Ccode\u003EMarkdownEmbedParagraphs\u003C/code\u003E case with\n additional kinds of paragraphs that can appear in literate F# scripts\n (such as various special commands to embed output of a snippet etc.)\n \nLiterateParagraph.ParagraphOptions \nParagraphOptions \nLiterateParagraph.CodeReference \nCodeReference \nLiterateParagraph.FsiOutputReference \nFsiOutputReference \nLiterateParagraph.FsiMergedOutputReference \nFsiMergedOutputReference \nLiterateParagraph.OutputReference \nOutputReference \nLiterateParagraph.ItValueReference \nItValueReference \nLiterateParagraph.ItRawReference \nItRawReference \nLiterateParagraph.ValueReference \nValueReference \nLiterateParagraph.LiterateCode \nLiterateCode \nLiterateParagraph.LanguageTaggedCode \nLanguageTaggedCode \nLiterateParagraph.RawBlock \nRawBlock","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ParagraphOptions","title":"LiterateParagraph.ParagraphOptions","content":"LiterateParagraph.ParagraphOptions \nParagraphOptions \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#CodeReference","title":"LiterateParagraph.CodeReference","content":"LiterateParagraph.CodeReference \nCodeReference \n (*** include:foo ***) - Include formatted snippet from other part of the document here","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#FsiOutputReference","title":"LiterateParagraph.FsiOutputReference","content":"LiterateParagraph.FsiOutputReference \nFsiOutputReference \n (*** include-fsi-output ***) - Include output from previous snippet\n (*** include-fsi-output:foo ***) - Include output from a named snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#FsiMergedOutputReference","title":"LiterateParagraph.FsiMergedOutputReference","content":"LiterateParagraph.FsiMergedOutputReference \nFsiMergedOutputReference \n (*** include-fsi-merged-output ***) - Include output from previous snippet\n (*** include-fsi-merged-output:foo ***) - Include output from a named snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#OutputReference","title":"LiterateParagraph.OutputReference","content":"LiterateParagraph.OutputReference \nOutputReference \n (*** include-fsi-output ***) - Include F# Interactive output from previous snippet\n (*** include-fsi-output:foo ***) - Include F# Interactive from a named snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ItValueReference","title":"LiterateParagraph.ItValueReference","content":"LiterateParagraph.ItValueReference \nItValueReference \n (*** include-it ***) - Include \u0022it\u0022 value from the subsequent snippet here\n (*** include-it:foo ***) - Include \u0022it\u0022 value from a named snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ItRawReference","title":"LiterateParagraph.ItRawReference","content":"LiterateParagraph.ItRawReference \nItRawReference \n (*** include-it-raw ***) - Include \u0022it\u0022 value from the subsequent snippet here as raw text (Not formatted as fsi)\n (*** include-it-raw:foo ***) - Include \u0022it\u0022 value from a named snippet as raw text (Not formatted as fsi)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ValueReference","title":"LiterateParagraph.ValueReference","content":"LiterateParagraph.ValueReference \nValueReference \n (*** include-value:foo ***) - Include the formatting of a specified value here","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#LiterateCode","title":"LiterateParagraph.LiterateCode","content":"LiterateParagraph.LiterateCode \nLiterateCode \n Embedded literate code snippet. Consists of source lines and options","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#LanguageTaggedCode","title":"LiterateParagraph.LanguageTaggedCode","content":"LiterateParagraph.LanguageTaggedCode \nLanguageTaggedCode \n Ordinary formatted code snippet in non-F# language (tagged with language code)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#RawBlock","title":"LiterateParagraph.RawBlock","content":"LiterateParagraph.RawBlock \nRawBlock \n Block simply emitted without any formatting equivalent to \u003Cpre\u003E tag in html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraphoptions.html","title":"LiterateParagraphOptions","content":"LiterateParagraphOptions \n Specifies the options for a literate paragraph \nLiterateParagraphOptions.Condition \nCondition","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraphoptions.html#Condition","title":"LiterateParagraphOptions.Condition","content":"LiterateParagraphOptions.Condition \nCondition \n Specifies a conditional for inclusion of the snippet paragraph","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatesource.html","title":"LiterateSource","content":"LiterateSource \n Represents the source of a literate document. \nLiterateSource.Markdown \nMarkdown \nLiterateSource.Script \nScript","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatesource.html#Markdown","title":"LiterateSource.Markdown","content":"LiterateSource.Markdown \nMarkdown \n A markdown source","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatesource.html#Script","title":"LiterateSource.Script","content":"LiterateSource.Script \nScript \n A parsed F# script file consisting of snippets.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html","title":"OutputKind","content":"OutputKind \n Defines the possible output types from literate script (HTML, Latex, Pynb) \nOutputKind.Extension \nExtension \nOutputKind.Html \nHtml \nOutputKind.Latex \nLatex \nOutputKind.Pynb \nPynb \nOutputKind.Fsx \nFsx \nOutputKind.Markdown \nMarkdown","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Extension","title":"OutputKind.Extension","content":"OutputKind.Extension \nExtension \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Html","title":"OutputKind.Html","content":"OutputKind.Html \nHtml \n Requests HTML output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Latex","title":"OutputKind.Latex","content":"OutputKind.Latex \nLatex \n Requests LaTeX output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Pynb","title":"OutputKind.Pynb","content":"OutputKind.Pynb \nPynb \n Requests Notebook output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Fsx","title":"OutputKind.Fsx","content":"OutputKind.Fsx \nFsx \n Requests F# Script output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Markdown","title":"OutputKind.Markdown","content":"OutputKind.Markdown \nMarkdown \n Requests Markdown output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html","title":"FsiEmbedKind","content":"FsiEmbedKind \n\n Represents a kind of thing that can be embedded\n \nFsiEmbedKind.FsiOutput \nFsiOutput \nFsiEmbedKind.FsiMergedOutput \nFsiMergedOutput \nFsiEmbedKind.ConsoleOutput \nConsoleOutput \nFsiEmbedKind.ItValue \nItValue \nFsiEmbedKind.ItRaw \nItRaw \nFsiEmbedKind.Value \nValue","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#FsiOutput","title":"FsiEmbedKind.FsiOutput","content":"FsiEmbedKind.FsiOutput \nFsiOutput \n The FSI output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#FsiMergedOutput","title":"FsiEmbedKind.FsiMergedOutput","content":"FsiEmbedKind.FsiMergedOutput \nFsiMergedOutput \n The combined FSI output and console output","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#ConsoleOutput","title":"FsiEmbedKind.ConsoleOutput","content":"FsiEmbedKind.ConsoleOutput \nConsoleOutput \n The stdout from this part of the execution (not including FSI output)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#ItValue","title":"FsiEmbedKind.ItValue","content":"FsiEmbedKind.ItValue \nItValue \n The \u0027it\u0027 value","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#ItRaw","title":"FsiEmbedKind.ItRaw","content":"FsiEmbedKind.ItRaw \nItRaw \n The \u0027it\u0027 value as raw text","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#Value","title":"FsiEmbedKind.Value","content":"FsiEmbedKind.Value \nValue \n A specific value","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html","title":"FsiEvaluationFailedInfo","content":"FsiEvaluationFailedInfo \n Record that is reported by the EvaluationFailed event when something\n goes wrong during evalutaiton of an expression \nFsiEvaluationFailedInfo.Text \nText \nFsiEvaluationFailedInfo.AsExpression \nAsExpression \nFsiEvaluationFailedInfo.File \nFile \nFsiEvaluationFailedInfo.Exception \nException \nFsiEvaluationFailedInfo.StdErr \nStdErr","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#Text","title":"FsiEvaluationFailedInfo.Text","content":"FsiEvaluationFailedInfo.Text \nText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#AsExpression","title":"FsiEvaluationFailedInfo.AsExpression","content":"FsiEvaluationFailedInfo.AsExpression \nAsExpression \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#File","title":"FsiEvaluationFailedInfo.File","content":"FsiEvaluationFailedInfo.File \nFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#Exception","title":"FsiEvaluationFailedInfo.Exception","content":"FsiEvaluationFailedInfo.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#StdErr","title":"FsiEvaluationFailedInfo.StdErr","content":"FsiEvaluationFailedInfo.StdErr \nStdErr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html","title":"FsiEvaluationResult","content":"FsiEvaluationResult \n Represents the result of evaluating an F# snippet. This contains\n the generated console output together with a result and its static type. \nFsiEvaluationResult.Output \nOutput \nFsiEvaluationResult.FsiOutput \nFsiOutput \nFsiEvaluationResult.FsiMergedOutput \nFsiMergedOutput \nFsiEvaluationResult.ItValue \nItValue \nFsiEvaluationResult.Result \nResult","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#Output","title":"FsiEvaluationResult.Output","content":"FsiEvaluationResult.Output \nOutput \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#FsiOutput","title":"FsiEvaluationResult.FsiOutput","content":"FsiEvaluationResult.FsiOutput \nFsiOutput \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#FsiMergedOutput","title":"FsiEvaluationResult.FsiMergedOutput","content":"FsiEvaluationResult.FsiMergedOutput \nFsiMergedOutput \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#ItValue","title":"FsiEvaluationResult.ItValue","content":"FsiEvaluationResult.ItValue \nItValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#Result","title":"FsiEvaluationResult.Result","content":"FsiEvaluationResult.Result \nResult \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html","title":"FsiEvaluator","content":"FsiEvaluator \n A wrapper for F# interactive service that is used to evaluate inline snippets \nFsiEvaluator.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFsiEvaluator.RegisterTransformation \nRegisterTransformation \nFsiEvaluator.EvaluationFailed \nEvaluationFailed","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#\u0060\u0060.ctor\u0060\u0060","title":"FsiEvaluator.\u0060\u0060.ctor\u0060\u0060","content":"FsiEvaluator.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#RegisterTransformation","title":"FsiEvaluator.RegisterTransformation","content":"FsiEvaluator.RegisterTransformation \nRegisterTransformation \n Register a function that formats (some) values that are produced by the evaluator.\n The specified function should return \u0027Some\u0027 when it knows how to format a value\n and it should return formatted","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#EvaluationFailed","title":"FsiEvaluator.EvaluationFailed","content":"FsiEvaluator.EvaluationFailed \nEvaluationFailed \n This event is fired whenever an evaluation of an expression fails","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html","title":"FsiEvaluatorConfig","content":"FsiEvaluatorConfig \n Provides configuration options for the FsiEvaluator \nFsiEvaluatorConfig.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFsiEvaluatorConfig.CreateNoOpFsiObject \nCreateNoOpFsiObject","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html#\u0060\u0060.ctor\u0060\u0060","title":"FsiEvaluatorConfig.\u0060\u0060.ctor\u0060\u0060","content":"FsiEvaluatorConfig.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html#CreateNoOpFsiObject","title":"FsiEvaluatorConfig.CreateNoOpFsiObject","content":"FsiEvaluatorConfig.CreateNoOpFsiObject \nCreateNoOpFsiObject \n Creates a dummy fsi object that does not affect the behaviour of F# Interactive\n (and simply ignores all operations that are done on it). You can use this to\n e.g. disable registered printers that would open new windows etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluationresult.html","title":"IFsiEvaluationResult","content":"IFsiEvaluationResult \n An interface that represents FSI evaluation result\n (we make this abstract so that evaluators can store other info)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html","title":"IFsiEvaluator","content":"IFsiEvaluator \n Represents an evaluator for F# snippets embedded in code \nIFsiEvaluator.Evaluate \nEvaluate \nIFsiEvaluator.Format \nFormat","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html#Evaluate","title":"IFsiEvaluator.Evaluate","content":"IFsiEvaluator.Evaluate \nEvaluate \n Called to evaluate a snippet","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html#Format","title":"IFsiEvaluator.Format","content":"IFsiEvaluator.Format \nFormat \n Called to format some part of evaluation result generated by FSI","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html","title":"Dsl","content":"Dsl \n \nDsl.\u0060\u0060#\u0060\u0060 \n\u0060\u0060#\u0060\u0060 \nDsl.\u0060\u0060##\u0060\u0060 \n\u0060\u0060##\u0060\u0060 \nDsl.\u0060\u0060###\u0060\u0060 \n\u0060\u0060###\u0060\u0060 \nDsl.\u0060\u0060####\u0060\u0060 \n\u0060\u0060####\u0060\u0060 \nDsl.\u0060\u0060#####\u0060\u0060 \n\u0060\u0060#####\u0060\u0060 \nDsl.strong \nstrong \nDsl.p \np \nDsl.span \nspan \nDsl.(!!) \n(!!) \nDsl.link \nlink \nDsl.ul \nul \nDsl.ol \nol \nDsl.table \ntable \nDsl.img \nimg","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#\u0060\u0060#\u0060\u0060","title":"Dsl.\u0060\u0060#\u0060\u0060","content":"Dsl.\u0060\u0060#\u0060\u0060 \n\u0060\u0060#\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#\u0060\u0060##\u0060\u0060","title":"Dsl.\u0060\u0060##\u0060\u0060","content":"Dsl.\u0060\u0060##\u0060\u0060 \n\u0060\u0060##\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#\u0060\u0060###\u0060\u0060","title":"Dsl.\u0060\u0060###\u0060\u0060","content":"Dsl.\u0060\u0060###\u0060\u0060 \n\u0060\u0060###\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#\u0060\u0060####\u0060\u0060","title":"Dsl.\u0060\u0060####\u0060\u0060","content":"Dsl.\u0060\u0060####\u0060\u0060 \n\u0060\u0060####\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#\u0060\u0060#####\u0060\u0060","title":"Dsl.\u0060\u0060#####\u0060\u0060","content":"Dsl.\u0060\u0060#####\u0060\u0060 \n\u0060\u0060#####\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#strong","title":"Dsl.strong","content":"Dsl.strong \nstrong \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#p","title":"Dsl.p","content":"Dsl.p \np \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#span","title":"Dsl.span","content":"Dsl.span \nspan \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#(!!)","title":"Dsl.(!!)","content":"Dsl.(!!) \n(!!) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#link","title":"Dsl.link","content":"Dsl.link \nlink \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#ul","title":"Dsl.ul","content":"Dsl.ul \nul \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#ol","title":"Dsl.ol","content":"Dsl.ol \nol \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#table","title":"Dsl.table","content":"Dsl.table \ntable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#img","title":"Dsl.img","content":"Dsl.img \nimg \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-htmlformatting.html","title":"HtmlFormatting","content":"HtmlFormatting \n \nHtmlFormatting.formatAsHtml \nformatAsHtml","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-htmlformatting.html#formatAsHtml","title":"HtmlFormatting.formatAsHtml","content":"HtmlFormatting.formatAsHtml \nformatAsHtml \n Format Markdown document and write the result to\n a specified TextWriter. Parameters specify newline character\n and a dictionary with link keys defined in the document.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html","title":"MarkdownPatterns","content":"MarkdownPatterns \n This module provides an easy way of processing Markdown documents.\n It lets you decompose documents into leafs and nodes with nested paragraphs. \nMarkdownPatterns.ParagraphLeafInfo \nParagraphLeafInfo \nMarkdownPatterns.ParagraphNestedInfo \nParagraphNestedInfo \nMarkdownPatterns.ParagraphSpansInfo \nParagraphSpansInfo \nMarkdownPatterns.SpanLeafInfo \nSpanLeafInfo \nMarkdownPatterns.SpanNodeInfo \nSpanNodeInfo \nMarkdownPatterns.SpanLeaf \nSpanLeaf \nMarkdownPatterns.SpanNode \nSpanNode \nMarkdownPatterns.ParagraphSpans \nParagraphSpans \nMarkdownPatterns.ParagraphLeaf \nParagraphLeaf \nMarkdownPatterns.ParagraphNested \nParagraphNested \nMarkdownPatterns.(|SpanLeaf|SpanNode|) \n(|SpanLeaf|SpanNode|) \nMarkdownPatterns.(|ParagraphLeaf|ParagraphNested|ParagraphSpans|) \n(|ParagraphLeaf|ParagraphNested|ParagraphSpans|)","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#SpanLeaf","title":"MarkdownPatterns.SpanLeaf","content":"MarkdownPatterns.SpanLeaf \nSpanLeaf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#SpanNode","title":"MarkdownPatterns.SpanNode","content":"MarkdownPatterns.SpanNode \nSpanNode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#ParagraphSpans","title":"MarkdownPatterns.ParagraphSpans","content":"MarkdownPatterns.ParagraphSpans \nParagraphSpans \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#ParagraphLeaf","title":"MarkdownPatterns.ParagraphLeaf","content":"MarkdownPatterns.ParagraphLeaf \nParagraphLeaf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#ParagraphNested","title":"MarkdownPatterns.ParagraphNested","content":"MarkdownPatterns.ParagraphNested \nParagraphNested \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#(|SpanLeaf|SpanNode|)","title":"MarkdownPatterns.(|SpanLeaf|SpanNode|)","content":"MarkdownPatterns.(|SpanLeaf|SpanNode|) \n(|SpanLeaf|SpanNode|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#(|ParagraphLeaf|ParagraphNested|ParagraphSpans|)","title":"MarkdownPatterns.(|ParagraphLeaf|ParagraphNested|ParagraphSpans|)","content":"MarkdownPatterns.(|ParagraphLeaf|ParagraphNested|ParagraphSpans|) \n(|ParagraphLeaf|ParagraphNested|ParagraphSpans|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-paragraphleafinfo.html","title":"ParagraphLeafInfo","content":"ParagraphLeafInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-paragraphnestedinfo.html","title":"ParagraphNestedInfo","content":"ParagraphNestedInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-paragraphspansinfo.html","title":"ParagraphSpansInfo","content":"ParagraphSpansInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-spanleafinfo.html","title":"SpanLeafInfo","content":"SpanLeafInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-spannodeinfo.html","title":"SpanNodeInfo","content":"SpanNodeInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html","title":"Markdown","content":"Markdown \n Static class that provides methods for formatting\n and transforming Markdown documents. \nMarkdown.Parse \nParse \nMarkdown.ToFsx \nToFsx \nMarkdown.ToHtml \nToHtml \nMarkdown.ToHtml \nToHtml \nMarkdown.ToLatex \nToLatex \nMarkdown.ToLatex \nToLatex \nMarkdown.ToMd \nToMd \nMarkdown.ToPynb \nToPynb \nMarkdown.WriteHtml \nWriteHtml \nMarkdown.WriteHtml \nWriteHtml \nMarkdown.WriteLatex \nWriteLatex \nMarkdown.WriteLatex \nWriteLatex","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#Parse","title":"Markdown.Parse","content":"Markdown.Parse \nParse \n Parse the specified text into a MarkdownDocument. Line breaks in the\n inline HTML (etc.) will be stored using the specified string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToFsx","title":"Markdown.ToFsx","content":"Markdown.ToFsx \nToFsx \n Transform the provided MarkdownDocument into Fsx and return the result as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml","title":"Markdown.ToHtml","content":"Markdown.ToHtml \nToHtml \n Transform Markdown document into HTML format.\n The result will be returned as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml","title":"Markdown.ToHtml","content":"Markdown.ToHtml \nToHtml \n Transform the provided MarkdownDocument into HTML\n format and return the result as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToLatex","title":"Markdown.ToLatex","content":"Markdown.ToLatex \nToLatex \n Transform Markdown text into LaTeX format. The result will be returned as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToLatex","title":"Markdown.ToLatex","content":"Markdown.ToLatex \nToLatex \n Transform the provided MarkdownDocument into LaTeX\n format and return the result as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToMd","title":"Markdown.ToMd","content":"Markdown.ToMd \nToMd \n Transform the provided MarkdownDocument into Markdown and return the result as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToPynb","title":"Markdown.ToPynb","content":"Markdown.ToPynb \nToPynb \n Transform the provided MarkdownDocument into Pynb and return the result as a string.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteHtml","title":"Markdown.WriteHtml","content":"Markdown.WriteHtml \nWriteHtml \n Transform Markdown text into HTML format. The result\n will be written to the provided TextWriter.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteHtml","title":"Markdown.WriteHtml","content":"Markdown.WriteHtml \nWriteHtml \n Transform the provided MarkdownDocument into HTML\n format and write the result to a given writer.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteLatex","title":"Markdown.WriteLatex","content":"Markdown.WriteLatex \nWriteLatex \n Transform Markdown document into LaTeX format. The result\n will be written to the provided TextWriter.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteLatex","title":"Markdown.WriteLatex","content":"Markdown.WriteLatex \nWriteLatex \n Transform the provided MarkdownDocument into LaTeX\n format and write the result to a given writer.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html","title":"MarkdownColumnAlignment","content":"MarkdownColumnAlignment \n Column in a table can be aligned to left, right, center or using the default alignment \nMarkdownColumnAlignment.AlignLeft \nAlignLeft \nMarkdownColumnAlignment.AlignRight \nAlignRight \nMarkdownColumnAlignment.AlignCenter \nAlignCenter \nMarkdownColumnAlignment.AlignDefault \nAlignDefault","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignLeft","title":"MarkdownColumnAlignment.AlignLeft","content":"MarkdownColumnAlignment.AlignLeft \nAlignLeft \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignRight","title":"MarkdownColumnAlignment.AlignRight","content":"MarkdownColumnAlignment.AlignRight \nAlignRight \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignCenter","title":"MarkdownColumnAlignment.AlignCenter","content":"MarkdownColumnAlignment.AlignCenter \nAlignCenter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignDefault","title":"MarkdownColumnAlignment.AlignDefault","content":"MarkdownColumnAlignment.AlignDefault \nAlignDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html","title":"MarkdownDocument","content":"MarkdownDocument \n\n Representation of a Markdown document - the representation of Paragraphs\n uses an F# discriminated union type and so is best used from F#.\n \nMarkdownDocument.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nMarkdownDocument.Paragraphs \nParagraphs \nMarkdownDocument.DefinedLinks \nDefinedLinks","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#\u0060\u0060.ctor\u0060\u0060","title":"MarkdownDocument.\u0060\u0060.ctor\u0060\u0060","content":"MarkdownDocument.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#Paragraphs","title":"MarkdownDocument.Paragraphs","content":"MarkdownDocument.Paragraphs \nParagraphs \n Returns a list of paragraphs in the document","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#DefinedLinks","title":"MarkdownDocument.DefinedLinks","content":"MarkdownDocument.DefinedLinks \nDefinedLinks \n Returns a dictionary containing explicitly defined links","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedparagraphs.html","title":"MarkdownEmbedParagraphs","content":"MarkdownEmbedParagraphs \n Provides an extensibility point for adding custom kinds of paragraphs into a document\n (MarkdownEmbedParagraphs values can be embedded using MarkdownParagraph.EmbedParagraphs) \nMarkdownEmbedParagraphs.Render \nRender","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedparagraphs.html#Render","title":"MarkdownEmbedParagraphs.Render","content":"MarkdownEmbedParagraphs.Render \nRender \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedspans.html","title":"MarkdownEmbedSpans","content":"MarkdownEmbedSpans \n Provides an extensibility point for adding custom kinds of spans into a document\n (MarkdownEmbedSpans values can be embedded using MarkdownSpan.EmbedSpans) \nMarkdownEmbedSpans.Render \nRender","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedspans.html#Render","title":"MarkdownEmbedSpans.Render","content":"MarkdownEmbedSpans.Render \nRender \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownlistkind.html","title":"MarkdownListKind","content":"MarkdownListKind \n\n A list kind can be Ordered or Unordered corresponding to \u003Ccode\u003E\u0026lt;ol\u0026gt;\u003C/code\u003E and \u003Ccode\u003E\u0026lt;ul\u0026gt;\u003C/code\u003E elements\n \nMarkdownListKind.Ordered \nOrdered \nMarkdownListKind.Unordered \nUnordered","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownlistkind.html#Ordered","title":"MarkdownListKind.Ordered","content":"MarkdownListKind.Ordered \nOrdered \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownlistkind.html#Unordered","title":"MarkdownListKind.Unordered","content":"MarkdownListKind.Unordered \nUnordered \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html","title":"MarkdownParagraph","content":"MarkdownParagraph \n A paragraph represents a (possibly) multi-line element of a Markdown document.\n Paragraphs are headings, inline paragraphs, code blocks, lists, quotations, tables and\n also embedded LaTeX blocks. \nMarkdownParagraph.Heading \nHeading \nMarkdownParagraph.Paragraph \nParagraph \nMarkdownParagraph.CodeBlock \nCodeBlock \nMarkdownParagraph.InlineHtmlBlock \nInlineHtmlBlock \nMarkdownParagraph.ListBlock \nListBlock \nMarkdownParagraph.QuotedBlock \nQuotedBlock \nMarkdownParagraph.Span \nSpan \nMarkdownParagraph.LatexBlock \nLatexBlock \nMarkdownParagraph.HorizontalRule \nHorizontalRule \nMarkdownParagraph.TableBlock \nTableBlock \nMarkdownParagraph.OtherBlock \nOtherBlock \nMarkdownParagraph.EmbedParagraphs \nEmbedParagraphs \nMarkdownParagraph.YamlFrontmatter \nYamlFrontmatter \nMarkdownParagraph.OutputBlock \nOutputBlock","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#Heading","title":"MarkdownParagraph.Heading","content":"MarkdownParagraph.Heading \nHeading \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#Paragraph","title":"MarkdownParagraph.Paragraph","content":"MarkdownParagraph.Paragraph \nParagraph \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#CodeBlock","title":"MarkdownParagraph.CodeBlock","content":"MarkdownParagraph.CodeBlock \nCodeBlock \n A code block, whether fenced or via indentation","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#InlineHtmlBlock","title":"MarkdownParagraph.InlineHtmlBlock","content":"MarkdownParagraph.InlineHtmlBlock \nInlineHtmlBlock \n A HTML block","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#ListBlock","title":"MarkdownParagraph.ListBlock","content":"MarkdownParagraph.ListBlock \nListBlock \n A Markdown List block","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#QuotedBlock","title":"MarkdownParagraph.QuotedBlock","content":"MarkdownParagraph.QuotedBlock \nQuotedBlock \n A Markdown Quote block","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#Span","title":"MarkdownParagraph.Span","content":"MarkdownParagraph.Span \nSpan \n A Markdown Span block","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#LatexBlock","title":"MarkdownParagraph.LatexBlock","content":"MarkdownParagraph.LatexBlock \nLatexBlock \n A Markdown Latex block","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#HorizontalRule","title":"MarkdownParagraph.HorizontalRule","content":"MarkdownParagraph.HorizontalRule \nHorizontalRule \n A Markdown Horizontal rule","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#TableBlock","title":"MarkdownParagraph.TableBlock","content":"MarkdownParagraph.TableBlock \nTableBlock \n A Markdown Table","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#OtherBlock","title":"MarkdownParagraph.OtherBlock","content":"MarkdownParagraph.OtherBlock \nOtherBlock \n Represents a block of markdown produced when parsing of code or tables or quoted blocks is suppressed","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#EmbedParagraphs","title":"MarkdownParagraph.EmbedParagraphs","content":"MarkdownParagraph.EmbedParagraphs \nEmbedParagraphs \n A special addition for computing paragraphs","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#YamlFrontmatter","title":"MarkdownParagraph.YamlFrontmatter","content":"MarkdownParagraph.YamlFrontmatter \nYamlFrontmatter \n A special addition for YAML-style frontmatter","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#OutputBlock","title":"MarkdownParagraph.OutputBlock","content":"MarkdownParagraph.OutputBlock \nOutputBlock \n A special addition for inserted outputs","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html","title":"MarkdownParagraphs","content":"MarkdownParagraphs \n A type alias for a list of paragraphs \nMarkdownParagraphs.Head \nHead \nMarkdownParagraphs.Item \nItem \nMarkdownParagraphs.Tail \nTail \nMarkdownParagraphs.IsEmpty \nIsEmpty \nMarkdownParagraphs.Length \nLength \nMarkdownParagraphs.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Head","title":"MarkdownParagraphs.Head","content":"MarkdownParagraphs.Head \nHead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Item","title":"MarkdownParagraphs.Item","content":"MarkdownParagraphs.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Tail","title":"MarkdownParagraphs.Tail","content":"MarkdownParagraphs.Tail \nTail \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#IsEmpty","title":"MarkdownParagraphs.IsEmpty","content":"MarkdownParagraphs.IsEmpty \nIsEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Length","title":"MarkdownParagraphs.Length","content":"MarkdownParagraphs.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Empty","title":"MarkdownParagraphs.Empty","content":"MarkdownParagraphs.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html","title":"MarkdownParseOptions","content":"MarkdownParseOptions \n Controls the parsing of markdown \nMarkdownParseOptions.None \nNone \nMarkdownParseOptions.ParseCodeAsOther \nParseCodeAsOther \nMarkdownParseOptions.ParseNonCodeAsOther \nParseNonCodeAsOther \nMarkdownParseOptions.AllowYamlFrontMatter \nAllowYamlFrontMatter","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#None","title":"MarkdownParseOptions.None","content":"MarkdownParseOptions.None \nNone \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#ParseCodeAsOther","title":"MarkdownParseOptions.ParseCodeAsOther","content":"MarkdownParseOptions.ParseCodeAsOther \nParseCodeAsOther \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#ParseNonCodeAsOther","title":"MarkdownParseOptions.ParseNonCodeAsOther","content":"MarkdownParseOptions.ParseNonCodeAsOther \nParseNonCodeAsOther \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#AllowYamlFrontMatter","title":"MarkdownParseOptions.AllowYamlFrontMatter","content":"MarkdownParseOptions.AllowYamlFrontMatter \nAllowYamlFrontMatter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html","title":"MarkdownSpan","content":"MarkdownSpan \n Represents inline formatting inside a paragraph. This can be literal (with text), various\n formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc. \nMarkdownSpan.Literal \nLiteral \nMarkdownSpan.InlineCode \nInlineCode \nMarkdownSpan.Strong \nStrong \nMarkdownSpan.Emphasis \nEmphasis \nMarkdownSpan.AnchorLink \nAnchorLink \nMarkdownSpan.DirectLink \nDirectLink \nMarkdownSpan.IndirectLink \nIndirectLink \nMarkdownSpan.DirectImage \nDirectImage \nMarkdownSpan.IndirectImage \nIndirectImage \nMarkdownSpan.HardLineBreak \nHardLineBreak \nMarkdownSpan.LatexInlineMath \nLatexInlineMath \nMarkdownSpan.LatexDisplayMath \nLatexDisplayMath \nMarkdownSpan.EmbedSpans \nEmbedSpans","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#Literal","title":"MarkdownSpan.Literal","content":"MarkdownSpan.Literal \nLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#InlineCode","title":"MarkdownSpan.InlineCode","content":"MarkdownSpan.InlineCode \nInlineCode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#Strong","title":"MarkdownSpan.Strong","content":"MarkdownSpan.Strong \nStrong \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#Emphasis","title":"MarkdownSpan.Emphasis","content":"MarkdownSpan.Emphasis \nEmphasis \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#AnchorLink","title":"MarkdownSpan.AnchorLink","content":"MarkdownSpan.AnchorLink \nAnchorLink \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#DirectLink","title":"MarkdownSpan.DirectLink","content":"MarkdownSpan.DirectLink \nDirectLink \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#IndirectLink","title":"MarkdownSpan.IndirectLink","content":"MarkdownSpan.IndirectLink \nIndirectLink \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#DirectImage","title":"MarkdownSpan.DirectImage","content":"MarkdownSpan.DirectImage \nDirectImage \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#IndirectImage","title":"MarkdownSpan.IndirectImage","content":"MarkdownSpan.IndirectImage \nIndirectImage \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#HardLineBreak","title":"MarkdownSpan.HardLineBreak","content":"MarkdownSpan.HardLineBreak \nHardLineBreak \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#LatexInlineMath","title":"MarkdownSpan.LatexInlineMath","content":"MarkdownSpan.LatexInlineMath \nLatexInlineMath \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#LatexDisplayMath","title":"MarkdownSpan.LatexDisplayMath","content":"MarkdownSpan.LatexDisplayMath \nLatexDisplayMath \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#EmbedSpans","title":"MarkdownSpan.EmbedSpans","content":"MarkdownSpan.EmbedSpans \nEmbedSpans \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html","title":"MarkdownSpans","content":"MarkdownSpans \n A type alias for a list of MarkdownSpan values \nMarkdownSpans.Head \nHead \nMarkdownSpans.Item \nItem \nMarkdownSpans.Tail \nTail \nMarkdownSpans.IsEmpty \nIsEmpty \nMarkdownSpans.Length \nLength \nMarkdownSpans.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Head","title":"MarkdownSpans.Head","content":"MarkdownSpans.Head \nHead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Item","title":"MarkdownSpans.Item","content":"MarkdownSpans.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Tail","title":"MarkdownSpans.Tail","content":"MarkdownSpans.Tail \nTail \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#IsEmpty","title":"MarkdownSpans.IsEmpty","content":"MarkdownSpans.IsEmpty \nIsEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Length","title":"MarkdownSpans.Length","content":"MarkdownSpans.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Empty","title":"MarkdownSpans.Empty","content":"MarkdownSpans.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html","title":"MarkdownTableRow","content":"MarkdownTableRow \n A type alias representing table row as a list of paragraphs \nMarkdownTableRow.Head \nHead \nMarkdownTableRow.Item \nItem \nMarkdownTableRow.Tail \nTail \nMarkdownTableRow.IsEmpty \nIsEmpty \nMarkdownTableRow.Length \nLength \nMarkdownTableRow.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Head","title":"MarkdownTableRow.Head","content":"MarkdownTableRow.Head \nHead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Item","title":"MarkdownTableRow.Item","content":"MarkdownTableRow.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Tail","title":"MarkdownTableRow.Tail","content":"MarkdownTableRow.Tail \nTail \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#IsEmpty","title":"MarkdownTableRow.IsEmpty","content":"MarkdownTableRow.IsEmpty \nIsEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Length","title":"MarkdownTableRow.Length","content":"MarkdownTableRow.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Empty","title":"MarkdownTableRow.Empty","content":"MarkdownTableRow.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrangemodule.html","title":"MarkdownRange","content":"MarkdownRange \n \nMarkdownRange.zero \nzero \nMarkdownRange.mergeRanges \nmergeRanges","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrangemodule.html#zero","title":"MarkdownRange.zero","content":"MarkdownRange.zero \nzero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrangemodule.html#mergeRanges","title":"MarkdownRange.mergeRanges","content":"MarkdownRange.mergeRanges \nmergeRanges \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html","title":"MarkdownRange","content":"MarkdownRange \n \nMarkdownRange.StartLine \nStartLine \nMarkdownRange.StartColumn \nStartColumn \nMarkdownRange.EndLine \nEndLine \nMarkdownRange.EndColumn \nEndColumn","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#StartLine","title":"MarkdownRange.StartLine","content":"MarkdownRange.StartLine \nStartLine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#StartColumn","title":"MarkdownRange.StartColumn","content":"MarkdownRange.StartColumn \nStartColumn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#EndLine","title":"MarkdownRange.EndLine","content":"MarkdownRange.EndLine \nEndLine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#EndColumn","title":"MarkdownRange.EndColumn","content":"MarkdownRange.EndColumn \nEndColumn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html","title":"ParamKeys","content":"ParamKeys \n Defines the parameter keys known to FSharp.Formatting processing code \nParamKeys.root \nroot \nParamKeys.\u0060\u0060fsdocs-authors\u0060\u0060 \n\u0060\u0060fsdocs-authors\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-collection-name\u0060\u0060 \n\u0060\u0060fsdocs-collection-name\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-content\u0060\u0060 \n\u0060\u0060fsdocs-content\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-page-content-list\u0060\u0060 \n\u0060\u0060fsdocs-page-content-list\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-collection-name-link\u0060\u0060 \n\u0060\u0060fsdocs-collection-name-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-copyright\u0060\u0060 \n\u0060\u0060fsdocs-copyright\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-license-link\u0060\u0060 \n\u0060\u0060fsdocs-license-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-list-of-namespaces\u0060\u0060 \n\u0060\u0060fsdocs-list-of-namespaces\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-list-of-documents\u0060\u0060 \n\u0060\u0060fsdocs-list-of-documents\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-logo-link\u0060\u0060 \n\u0060\u0060fsdocs-logo-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-logo-src\u0060\u0060 \n\u0060\u0060fsdocs-logo-src\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-favicon-src\u0060\u0060 \n\u0060\u0060fsdocs-favicon-src\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-package-license-expression\u0060\u0060 \n\u0060\u0060fsdocs-package-license-expression\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-package-project-url\u0060\u0060 \n\u0060\u0060fsdocs-package-project-url\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-package-tags\u0060\u0060 \n\u0060\u0060fsdocs-package-tags\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-package-version\u0060\u0060 \n\u0060\u0060fsdocs-package-version\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-package-icon-url\u0060\u0060 \n\u0060\u0060fsdocs-package-icon-url\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-page-title\u0060\u0060 \n\u0060\u0060fsdocs-page-title\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-page-source\u0060\u0060 \n\u0060\u0060fsdocs-page-source\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-release-notes-link\u0060\u0060 \n\u0060\u0060fsdocs-release-notes-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-repository-branch\u0060\u0060 \n\u0060\u0060fsdocs-repository-branch\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-repository-commit\u0060\u0060 \n\u0060\u0060fsdocs-repository-commit\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-repository-link\u0060\u0060 \n\u0060\u0060fsdocs-repository-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-source\u0060\u0060 \n\u0060\u0060fsdocs-source\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-source-filename\u0060\u0060 \n\u0060\u0060fsdocs-source-filename\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-source-basename\u0060\u0060 \n\u0060\u0060fsdocs-source-basename\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-theme\u0060\u0060 \n\u0060\u0060fsdocs-theme\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-tooltips\u0060\u0060 \n\u0060\u0060fsdocs-tooltips\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-watch-script\u0060\u0060 \n\u0060\u0060fsdocs-watch-script\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-header-content\u0060\u0060 \n\u0060\u0060fsdocs-menu-header-content\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-header-id\u0060\u0060 \n\u0060\u0060fsdocs-menu-header-id\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-header-active-class\u0060\u0060 \n\u0060\u0060fsdocs-menu-header-active-class\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-items\u0060\u0060 \n\u0060\u0060fsdocs-menu-items\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-item-link\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-item-content\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-content\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-item-id\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-id\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-menu-item-active-class\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-active-class\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-previous-page-link\u0060\u0060 \n\u0060\u0060fsdocs-previous-page-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-next-page-link\u0060\u0060 \n\u0060\u0060fsdocs-next-page-link\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-head-extra\u0060\u0060 \n\u0060\u0060fsdocs-head-extra\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-body-extra\u0060\u0060 \n\u0060\u0060fsdocs-body-extra\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-body-class\u0060\u0060 \n\u0060\u0060fsdocs-body-class\u0060\u0060 \nParamKeys.\u0060\u0060fsdocs-meta-tags\u0060\u0060 \n\u0060\u0060fsdocs-meta-tags\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#root","title":"ParamKeys.root","content":"ParamKeys.root \nroot \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-authors\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-authors\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-authors\u0060\u0060 \n\u0060\u0060fsdocs-authors\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-collection-name\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-collection-name\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-collection-name\u0060\u0060 \n\u0060\u0060fsdocs-collection-name\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-content\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-content\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-content\u0060\u0060 \n\u0060\u0060fsdocs-content\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-page-content-list\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-page-content-list\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-page-content-list\u0060\u0060 \n\u0060\u0060fsdocs-page-content-list\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-collection-name-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-collection-name-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-collection-name-link\u0060\u0060 \n\u0060\u0060fsdocs-collection-name-link\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-copyright\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-copyright\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-copyright\u0060\u0060 \n\u0060\u0060fsdocs-copyright\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-license-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-license-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-license-link\u0060\u0060 \n\u0060\u0060fsdocs-license-link\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-list-of-namespaces\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-list-of-namespaces\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-list-of-namespaces\u0060\u0060 \n\u0060\u0060fsdocs-list-of-namespaces\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-list-of-documents\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-list-of-documents\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-list-of-documents\u0060\u0060 \n\u0060\u0060fsdocs-list-of-documents\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-logo-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-logo-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-logo-link\u0060\u0060 \n\u0060\u0060fsdocs-logo-link\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-logo-src\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-logo-src\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-logo-src\u0060\u0060 \n\u0060\u0060fsdocs-logo-src\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-favicon-src\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-favicon-src\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-favicon-src\u0060\u0060 \n\u0060\u0060fsdocs-favicon-src\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-package-license-expression\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-package-license-expression\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-package-license-expression\u0060\u0060 \n\u0060\u0060fsdocs-package-license-expression\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-package-project-url\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-package-project-url\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-package-project-url\u0060\u0060 \n\u0060\u0060fsdocs-package-project-url\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-package-tags\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-package-tags\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-package-tags\u0060\u0060 \n\u0060\u0060fsdocs-package-tags\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-package-version\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-package-version\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-package-version\u0060\u0060 \n\u0060\u0060fsdocs-package-version\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-package-icon-url\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-package-icon-url\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-package-icon-url\u0060\u0060 \n\u0060\u0060fsdocs-package-icon-url\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-page-title\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-page-title\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-page-title\u0060\u0060 \n\u0060\u0060fsdocs-page-title\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-page-source\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-page-source\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-page-source\u0060\u0060 \n\u0060\u0060fsdocs-page-source\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-release-notes-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-release-notes-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-release-notes-link\u0060\u0060 \n\u0060\u0060fsdocs-release-notes-link\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-repository-branch\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-repository-branch\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-repository-branch\u0060\u0060 \n\u0060\u0060fsdocs-repository-branch\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-repository-commit\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-repository-commit\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-repository-commit\u0060\u0060 \n\u0060\u0060fsdocs-repository-commit\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-repository-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-repository-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-repository-link\u0060\u0060 \n\u0060\u0060fsdocs-repository-link\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-source\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-source\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-source\u0060\u0060 \n\u0060\u0060fsdocs-source\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-source-filename\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-source-filename\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-source-filename\u0060\u0060 \n\u0060\u0060fsdocs-source-filename\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-source-basename\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-source-basename\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-source-basename\u0060\u0060 \n\u0060\u0060fsdocs-source-basename\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-theme\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-theme\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-theme\u0060\u0060 \n\u0060\u0060fsdocs-theme\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-tooltips\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-tooltips\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-tooltips\u0060\u0060 \n\u0060\u0060fsdocs-tooltips\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-watch-script\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-watch-script\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-watch-script\u0060\u0060 \n\u0060\u0060fsdocs-watch-script\u0060\u0060 \n A parameter key known to FSharp.Formatting","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-header-content\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-header-content\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-header-content\u0060\u0060 \n\u0060\u0060fsdocs-menu-header-content\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu_template.html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-header-id\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-header-id\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-header-id\u0060\u0060 \n\u0060\u0060fsdocs-menu-header-id\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu_template.html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-header-active-class\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-header-active-class\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-header-active-class\u0060\u0060 \n\u0060\u0060fsdocs-menu-header-active-class\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu_template.html\n This will be an empty string if the category is not active.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-items\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-items\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-items\u0060\u0060 \n\u0060\u0060fsdocs-menu-items\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu_template.html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-item-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-item-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-item-link\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-link\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu-item_template.html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-item-content\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-item-content\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-item-content\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-content\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu-item_template.html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-item-id\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-item-id\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-item-id\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-id\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu-item_template.html","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-menu-item-active-class\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-menu-item-active-class\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-menu-item-active-class\u0060\u0060 \n\u0060\u0060fsdocs-menu-item-active-class\u0060\u0060 \n A parameter key known to FSharp.Formatting, available in _menu-item_template.html\n /// This will be an empty string if the item is not active.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-previous-page-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-previous-page-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-previous-page-link\u0060\u0060 \n\u0060\u0060fsdocs-previous-page-link\u0060\u0060 \n A parameter key known to FSharp.Formatting, available when frontmatter is used correctly","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-next-page-link\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-next-page-link\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-next-page-link\u0060\u0060 \n\u0060\u0060fsdocs-next-page-link\u0060\u0060 \n A parameter key known to FSharp.Formatting, available when frontmatter is used correctly","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-head-extra\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-head-extra\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-head-extra\u0060\u0060 \n\u0060\u0060fsdocs-head-extra\u0060\u0060 \n A parameter key known to FSharp.Formatting, available when \u0060_head.html\u0060 exists in the input folder.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-body-extra\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-body-extra\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-body-extra\u0060\u0060 \n\u0060\u0060fsdocs-body-extra\u0060\u0060 \n A parameter key known to FSharp.Formatting, available when \u0060_head.html\u0060 exists in the input folder.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-body-class\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-body-class\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-body-class\u0060\u0060 \n\u0060\u0060fsdocs-body-class\u0060\u0060 \n A parameter key known to FSharp.Formatting, either \u0027content\u0027 or \u0027api-doc\u0027\n Mean to be used on the \u0060class\u0060 attribute in the \u0060\u003Cbody\u003E\u0060 tag.\n This helps to differentiate styles between API docs and custom content.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-meta-tags\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-meta-tags\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-meta-tags\u0060\u0060 \n\u0060\u0060fsdocs-meta-tags\u0060\u0060 \n A parameter key known to FSharp.Formatting, it is HTML composed from additional frontmatter information.\n Such as tags and description\n This can be empty when both properties are not provided for the current page.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html","title":"FrontMatterFile","content":"FrontMatterFile \n Meta data from files that contains front matter\n Used to determine upfront which files have front matter so that previous and next substitutes can be discovered. \nFrontMatterFile.ParseFromLines \nParseFromLines \nFrontMatterFile.FileName \nFileName \nFrontMatterFile.Category \nCategory \nFrontMatterFile.CategoryIndex \nCategoryIndex \nFrontMatterFile.Index \nIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#ParseFromLines","title":"FrontMatterFile.ParseFromLines","content":"FrontMatterFile.ParseFromLines \nParseFromLines \n Parses the category, categoryindex and index from the frontmatter lines","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#FileName","title":"FrontMatterFile.FileName","content":"FrontMatterFile.FileName \nFileName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#Category","title":"FrontMatterFile.Category","content":"FrontMatterFile.Category \nCategory \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#CategoryIndex","title":"FrontMatterFile.CategoryIndex","content":"FrontMatterFile.CategoryIndex \nCategoryIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#Index","title":"FrontMatterFile.Index","content":"FrontMatterFile.Index \nIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkey.html","title":"ParamKey","content":"ParamKey \n\n A parameter key\n \nParamKey.ParamKey \nParamKey","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkey.html#ParamKey","title":"ParamKey.ParamKey","content":"ParamKey.ParamKey \nParamKey \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html","title":"Substitutions","content":"Substitutions \n A list of parameters for substituting in templates, indexed by parameter keys \nSubstitutions.Head \nHead \nSubstitutions.Item \nItem \nSubstitutions.Tail \nTail \nSubstitutions.IsEmpty \nIsEmpty \nSubstitutions.Length \nLength \nSubstitutions.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Head","title":"Substitutions.Head","content":"Substitutions.Head \nHead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Item","title":"Substitutions.Item","content":"Substitutions.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Tail","title":"Substitutions.Tail","content":"Substitutions.Tail \nTail \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#IsEmpty","title":"Substitutions.IsEmpty","content":"Substitutions.IsEmpty \nIsEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Length","title":"Substitutions.Length","content":"Substitutions.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Empty","title":"Substitutions.Empty","content":"Substitutions.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/index.html","title":"F# Formatting: Documentation Tools for F# Code\n","content":"F# Formatting: Documentation Tools for F# Code\nFSharp.Formatting is a set of libraries and tools for processing F# script files, markdown and for\ngenerating API documentation. F# Formatting package is used by this project and many other repositories.\nTo use the tool, install and use the fsdocs tool in a typical F# project with\nF# project files plus markdown and script content in the docs directory:\ndotnet tool install fsdocs-tool\ndotnet fsdocs build \ndotnet fsdocs watch\n\nTo use the tool, explore the following topics:\n\nAuthoring Content - explains the content expected in the docs directory for the fsdocs tool.\nUsing the Command line tool - explains how to use the fsdocs tool.\n\nGenerating API documentation - how to generate HTML documentation\nfrom \u0022XML comments\u0022 in your .NET libraries. The tool handles comments written in\nMarkdown too.\n\nStyling - explains some options for styling the output of fsdocs.\n\nUsing literate programming - explains how to generate documentation\nfor your projects or to write nicely formatted F# blog posts.\n\n\nEmbedding F# outputs in literate programming - provides more details on literate programming and\nexplains how to embed results of a literate script file in the generated output. This way,\nyou can easily format the results of running your code!\n\n\nUsing FSharp.Formatting as a library\nF# Formatting is also available on NuGet as a set of libraries.\n\n\nMarkdown parser - explains the F# Markdown\nprocessor that is available in this library with some basic examples of\ndocument processing.\n\n\nF# code formatting - more details about the F# code\nformatter and how to use it to obtain information about F# source files.\n\n\nMore information\nThe documentation for this library is generated automatically using the tools\nbuilt here. If you spot a typo, please submit a pull request! The source Markdown and F# script files are\navailable in the docs folder on GitHub.\nThe project is hosted on GitHub where you can\nreport issues, fork the project and submit pull requests.\nSee the License file in the GitHub repository.\n","headings":["F# Formatting: Documentation Tools for F# Code","Using FSharp.Formatting as a library","More information"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/codeformat.html","title":"Code formatting\n","content":"\n\u0026emsp;\n\u0026emsp;\n\nCode formatting\nThis page demonstrates how to use FSharp.Formatting.CodeFormat to tokenize\nF# source code, obtain information about the source code (mainly tooltips\nfrom the type-checker) and how to turn the code into a nicely formatted HTML.\nFirst, we need to load the assembly and open necessary namespaces:\nopen FSharp.Formatting.CodeFormat\nopen System.Reflection\n\nIf you want to process multiple snippets, it is a good idea to keep the\nformatting agent around if possible. The agent needs to load the F# compiler\n(which needs to load various files itself) and so this takes a long time.\nProcessing F# source\nThe formatting agent provides a CodeFormatAgent.ParseAndCheckSource method (together with an asynchronous\nversion for use from F# and also a version that returns a .NET Task for C#).\nTo call the method, we define a simple F# code as a string:\nlet source =\n \u0026quot;\u0026quot;\u0026quot;\n let hello () =\n printfn \u0026quot;Hello world\u0026quot;\n \u0026quot;\u0026quot;\u0026quot;\n\nlet snippets, diagnostics =\n CodeFormatter.ParseAndCheckSource(\u0026quot;C:\\\\snippet.fsx\u0026quot;, source, None, None, ignore)\n\nWhen calling the method, you need to specify a file name and the actual content\nof the script file. The file does not have to physically exist. It is used by the\nF# compiler to resolve relative references (e.g. #r) and to automatically name\nthe module including all code in the file.\nYou can also specify additional parameters, such as *.dll references, by passing\na third argument with compiler options (e.g. \u0022-r:Foo.dll -r:Bar.dll\u0022).\nThis operation might take some time, so it is a good idea to use an asynchronous\nvariant of the method. It returns two arrays - the first contains F# snippets\nin the source code and the second contains any errors reported by the compiler.\nA single source file can include multiple snippets using the same formatting tags\nas those used on fssnip.net as documented in the\nabout page.\nWorking with returned tokens\nEach returned snippet is essentially just a collection of lines and each line\nconsists of a sequence of tokens. The following snippet prints basic information\nabout the tokens of our sample snippet:\n// Get the first snippet and obtain list of lines\nlet (Snippet (title, lines)) = snippets |\u0026gt; Seq.head\n\n// Iterate over all lines and all tokens on each line\nfor (Line (_, tokens)) in lines do\n for token in tokens do\n match token with\n | TokenSpan.Token (kind, code, tip) -\u0026gt;\n printf \u0026quot;%s\u0026quot; code\n\n tip\n |\u0026gt; Option.iter (fun spans -\u0026gt; printfn \u0026quot;%A\u0026quot; spans)\n | TokenSpan.Omitted _\n | TokenSpan.Output _\n | TokenSpan.Error _ -\u0026gt; ()\n\n printfn \u0026quot;\u0026quot;\n\nThe TokenSpan.Token is the most important kind of token. It consists of a kind\n(identifier, keyword, etc.), the original F# code and tool tip information.\nThe tool tip is further formatted using a simple document format, but we simply\nprint the value using the F# pretty printing, so the result looks as follows:\nlet hello[Literal \u0026quot;val hello : unit -\u0026gt; unit\u0026quot;; ...] () =\n printfn[Literal \u0026quot;val printfn : TextWriterFormat\u0026lt;\u0026#39;T\u0026gt; -\u0026gt; \u0026#39;T\u0026quot;; ...] \u0026quot;Hello world\u0026quot;\n\nThe Omitted token is generated if you use the special (*[omit:...]*) command.\nThe Output token is generated if you use the // [fsi:...] command to format\noutput returned by F# interactive. The Error command wraps code that should be\nunderlined with a red squiggle if the code contains an error.\nGenerating HTML output\nFinally, the CodeFormat type also includes a method CodeFormat.FormatHtml that can be used\nto generate nice HTML output from an F# snippet. This is used, for example, on\nF# Snippets. The following example shows how to call it:\nlet prefix = \u0026quot;fst\u0026quot;\nlet html = CodeFormat.FormatHtml(snippets, prefix)\n\n// Print all snippets, in case there is more of them\nfor snip in html.Snippets do\n printfn \u0026quot;%s\u0026quot; snip.Content\n\n// Print HTML code that is generated for ToolTips\nprintfn \u0026quot;%s\u0026quot; html.ToolTip\n\nIf the input contains multiple snippets separated using the //[snippet:...] comment, e.g.:\n\n1: \n2: \n3: \n4: \n5: \n6: \n7: \n\n\n// [snippet: First sample]\nprintf \u0022The answer is: %A\u0022 42\n// [/snippet]\n// [snippet: Second sample]\nprintf \u0022Hello world!\u0022\n// [/snippet]\n\n\n\n\nthen the formatter returns multiple HTML blocks. However, the generated tool tips\nare shared by all snippets (to save space) and so they are returned separately.\n","headings":["Code formatting","Processing F# source","Working with returned tokens","Generating HTML output"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/literate.html","title":"Literate Scripts\n","content":"\n\u0026emsp;\n\u0026emsp;\n\nLiterate Scripts\nThe following example shows most of the features that can be used in a literate\nF# script file with .fsx extension. Most of the features should be quite self-explanatory:\n(**\n# First-level heading\nSome more documentation using \u0060Markdown\u0060.\n*)\n\nlet helloWorld() = printfn \u0026quot;Hello world!\u0026quot;\n\n(**\n## Second-level heading\nWith some more documentation\n*)\n\nlet numbers = [ 0 .. 99 ]\n(*** include-value: numbers ***)\n\nList.sum numbers\n(*** include-it ***)\n\nThe F# script files is processed as follows:\n\n\nA multi-line comment starting with (** and ending with *) is\nturned into text and is processed using the F# Markdown processor\n(which supports standard Markdown commands).\n\n\nA single-line comment starting with (*** and ending with ***)\nis treated as a special command. The command can consist of\nkey, key: value or key=value pairs.\n\n\n\n\n\nLiterate Command\nDescription\n\n\n\n\n(** ... *)\nMarkdown\n\n\n(*** condition: prepare ***)\nUtilise a code snippet when analyzing for tooltips or executing for outputs\n\n\n(*** condition: ipynb ***)\nInclude a code snippet when making a .ipynb notebook\n\n\n(*** condition: tex ***)\nInclude a code snippet when making a .tex output\n\n\n(*** condition: html ***)\nInclude a code snippet when making HTML output\n\n\n(*** hide ***)\nHide the subsequent snippet\n\n\n(*** raw ***)\nThe subsequent code is treated as raw text\n\n\n\n\nNaming and including snippets\nThe command define defines a named snippet (such as final-sample) and removes the command together with\nthe following F# code block from the main document. The snippet can then\nbe referred to in \u0027include\u0027. This makes it\npossible to write documents without the ordering requirements of the\nF# language.\n\n\n\nLiterate Command\nDescription\n\n\n\n\n(*** define: snippet-name ***)\nDefine a named snippet\n\n\n(*** include: snippet-name ***)\nInclude the code of the named snippet\n\n\n\n\nNaming and including outputs\n\n\n\nLiterate Command\nDescription\n\n\n\n\n(*** define-output: output-name ***)\nDefine a name for the outputs of the preceding snippet\n\n\n(*** include-output ***)\nThe console output of the preceding snippet\n\n\n(*** include-output: output-name ***)\nThe console output of the snippet (named with define-output)\n\n\n(*** include-fsi-output ***)\nThe F# Interactive output of the preceding snippet\n\n\n(*** include-fsi-output: output-name ***)\nThe F# Interactive output of the snippet (named with define-output)\n\n\n(*** include-fsi-merged-output ***)\nThe merge of console output and F# Interactive output of the preceding snippet\n\n\n(*** include-fsi-merged-output: output-name ***)\nThe merge of console output and F# Interactive output of the snippet (named with define-output)\n\n\n(*** include-it ***)\nThe formatted result of the preceding snippet\n\n\n(*** include-it: output-name ***)\nThe formatted result of the snippet (named with define-output)\n\n\n(*** include-it-raw ***)\nThe unformatted result of the preceding snippet\n\n\n(*** include-it-raw: output-name ***)\nThe unformatted result of the snippet (named with define-output)\n\n\n(*** include-value: value-name ***)\nThe formatted value, an F# identifier name\n\n\n\n\nHiding code snippets\nThe command hide specifies that the following F# code block (until the next comment or command) should be\nomitted from the output.\nEvaluating and formatting results\nThe commands to evaluate and format results are explained in evaluation.\nYou must build your documentation with evaluation turned on using --eval.\nSubstitutions\nSubstitutions are applied to content, see content.\nLiterate Markdown Documents\nFor files with .md extension, the entire file is a Markdown document, which may\ncontain F# code snippets (but also other code snippets). As usual, snippets are\nindented with four spaces. In addition, the snippets can be annotated with special\ncommands. Some of them are demonstrated in the following example:\n# First-level heading\n\n [hide]\n let print s = printfn \u0022%s\u0022 s\n\nSome more documentation using \u0060Markdown\u0060.\n\n [module=Hello]\n let helloWorld() = print \u0022Hello world!\u0022\n\n## Second-level heading\nWith some more documentation\n\n [lang=csharp]\n Console.WriteLine(\u0022Hello world!\u0022);\n\nWhen processing the document, all F# snippets are copied to a separate file that\nis type-checked using the F# compiler (to obtain colours and tool tips).\nThe commands are written on the first line of the named snippet, wrapped in [...]:\n\n\nThe hide command specifies that the F# snippet should not be included in the\nfinal document. This can be used to include code that is needed to type-check\nthe code, but is not visible to the reader.\n\n\nThe module=Foo command can be used to specify F# module where the snippet\nis placed. Use this command if you need multiple versions of the same snippet\nor if you need to separate code from different snippets.\n\n\nThe lang=foo command specifies the language of the named snippet. If the language\nis other than fsharp, the snippet is copied to the output as \u0026lt;pre\u0026gt; HTML\ntag without any processing.\n\n\nLaTeX in Literate Scripts and Markdown Documents\nLiterate Scripts may contain LaTeX sections in Markdown using these forms:\n\nSingle line latex starting with $$.\nA block delimited by \\begin{equation}...\\end{equation} or \\begin{align}...\\end{align}.\n\nAn indented paragraph starting with $$$. This is F#-literate-specific and corresponds to\n\\begin{equation}...\\end{equation}.\n\n\nFor example\n$$\\frac{x}{y}$$\n\n\\begin{equation}\n \\frac{d}{dx} \\left. \\left( x \\left( \\left. \\frac{d}{dy} x y \\; \\right|_{y=3} \\right) \\right) \\right|_{x=2}\n\\end{equation}\n\nBecomes\n\\[\\frac{x}{y}\\]\n\\[ \\frac{d}{dx} \\left. \\left( x \\left( \\left. \\frac{d}{dy} x y \\; \\right|_{y=3} \\right) \\right) \\right|_{x=2}\\]\nThe LaTeX will also be used in HTML and iPython notebook outputs.\nMaking literate scripts work for different outputs\nLiterate scripts and markdown can by turned into LaTex, Python Notebooks and F# scripts.\nA header may be needed to get the code to load, a typical example is this:\n (*** condition: prepare ***)\n #nowarn \u0022211\u0022\n #I \u0022../src/FSharp.Formatting/bin/Release/netstandard2.1\u0022\n #r \u0022FSharp.Formatting.Common.dll\u0022\n #r \u0022FSharp.Formatting.Markdown.dll\u0022\n #r \u0022FSharp.Formatting.CodeFormat.dll\u0022\n #r \u0022FSharp.Formatting.Literate.dll\u0022\n (*** condition: fsx ***)\n#if FSX\n #r \u0022nuget: FSharp.Formatting,1.0.0\u0022\n#endif // FSX\n (*** condition: ipynb ***)\n#if IPYNB\n #r \u0022nuget: FSharp.Formatting,1.0.0\u0022\n#endif // IPYNB\n\nProcessing literate files programatically\nTo process file Use the two static methods to turn single documents into HTML\nas follows using functionality from the Literate type:\nopen System.IO\nopen FSharp.Formatting.Literate\n\nlet source = __SOURCE_DIRECTORY__\nlet template = Path.Combine(source, \u0026quot;template.html\u0026quot;)\n\nlet script = Path.Combine(source, \u0026quot;../docs/script.fsx\u0026quot;)\n\nLiterate.ConvertScriptFile(script, template)\n\nlet doc = Path.Combine(source, \u0026quot;../docs/document.md\u0026quot;)\n\nLiterate.ConvertMarkdownFile(doc, template)\n\nThe following sample also uses optional parameter parameters to specify additional\nkeywords that will be replaced in the template file (this matches the template-project.html\nfile which is included as a sample in the package):\n// Load the template \u0026amp; specify project information\nlet projTemplate = source \u002B \u0026quot;template-project.html\u0026quot;\n\nlet projInfo =\n [ \u0026quot;fsdocs-authors\u0026quot;, \u0026quot;Tomas Petricek\u0026quot;\n \u0026quot;fsdocs-source-link\u0026quot;, \u0026quot;https://github.com/fsprojects/FSharp.Formatting\u0026quot;\n \u0026quot;fsdocs-collection-name\u0026quot;, \u0026quot;F# Formatting\u0026quot; ]\n\nThe methods used above (Literate.ConvertScriptFile, Literate.ConvertMarkdownFile)\nproduce HTML output by default, but they can be also used to produce LaTeX output. This is done\nby setting the output kind. The following\nexample shows how to call the methods to generate LaTeX documents:\nlet templateTex = Path.Combine(source, \u0026quot;template.tex\u0026quot;)\n\nlet scriptTex = Path.Combine(source, \u0026quot;../docs/script.fsx\u0026quot;)\n\nLiterate.ConvertScriptFile(scriptTex, templateTex, outputKind = OutputKind.Latex)\n\nlet docTex = Path.Combine(source, \u0026quot;../docs/document.md\u0026quot;)\n\nLiterate.ConvertMarkdownFile(docTex, templateTex, outputKind = OutputKind.Latex)\n\nThe methods used above (ConvertScriptFile, ConvertMarkdownFile)\ncan also produce iPython Notebook output. This is done\nby setting the named parameter format to OutputKind.Pynb:\n// Process script file, Markdown document and a directory\nlet scriptPynb = Path.Combine(source, \u0026quot;../docs/script.fsx\u0026quot;)\n\nLiterate.ConvertScriptFile(scriptPynb, outputKind = OutputKind.Pynb)\n\nlet docPynb = Path.Combine(source, \u0026quot;../docs/document.md\u0026quot;)\n\nLiterate.ConvertMarkdownFile(docPynb, outputKind = OutputKind.Pynb)\n\nAll of the three methods discussed in the previous two sections take a number of optional\nparameters that can be used to tweak how the formatting works\n","headings":["Literate Scripts","Naming and including snippets","Naming and including outputs","Hiding code snippets","Evaluating and formatting results","Substitutions","Literate Markdown Documents","LaTeX in Literate Scripts and Markdown Documents","Making literate scripts work for different outputs","Processing literate files programatically"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/upgrade.html","title":"Upgrading to fsdocs\n","content":"\nUpgrading to fsdocs\nHere are the typical steps to upgrade a repo based on ProjectScaffold to use fsdocs\n\n\nRun\ndotnet new tool\ndotnet tool install fsdocs-tool\n\n\nDelete all of docs\\tools particularly docs\\tool\\generate.fsx. Keep a copy of any templates for reference as you\u0027ll have to copy some bits across to the new template.\nPut your docs directory so it reflects the final shape of the site. For example move the content of docs\\input\\* and docs\\files\\* directly to docs\\*\nFollow the notes in styling to start to style your site.\n\nRun\ndotnet fsdocs watch\n\nand edit and test your docs.\n\n\nIf using FAKE adjust build.fsx e.g.\nTarget.create \u0022GenerateDocs\u0022 (fun _ -\u0026gt;\n Shell.cleanDir \u0022.fsdocs\u0022\n DotNet.exec id \u0022fsdocs\u0022 \u0022build --clean\u0022 |\u0026gt; ignore\n)\n\nTarget.create \u0022ReleaseDocs\u0022 (fun _ -\u0026gt;\n Git.Repository.clone \u0022\u0022 projectRepo \u0022temp/gh-pages\u0022\n Git.Branches.checkoutBranch \u0022temp/gh-pages\u0022 \u0022gh-pages\u0022\n Shell.copyRecursive \u0022output\u0022 \u0022temp/gh-pages\u0022 true |\u0026gt; printfn \u0022%A\u0022\n Git.CommandHelper.runSimpleGitCommand \u0022temp/gh-pages\u0022 \u0022add .\u0022 |\u0026gt; printfn \u0022%s\u0022\n let cmd = sprintf \u0022\u0022\u0022commit -a -m \u0022Update generated documentation for version %s\u0022\u0022\u0022 release.NugetVersion\n Git.CommandHelper.runSimpleGitCommand \u0022temp/gh-pages\u0022 cmd |\u0026gt; printfn \u0022%s\u0022\n Git.Branches.push \u0022temp/gh-pages\u0022\n)\n\n\n\nConsider creating docs\\_template.fsx and docs\\_template.ipynb to enable co-generation of F# scripts and F# notebooks.\nIf you add support for notebooks and scripts, consider adding mybinder links to each of your literate executable content pages. For example like this.\nAlso add load sections to make sure your notebooks and scripts contain the right content to load packages out of repo. For example like this.\n\n\nSample commands:\ndotnet tool install fsdocs-tool --local\ngit add dotnet-tools.json \ngit rm -fr docs/tools\ngit mv docs/input/* docs\ngit mv docs/files/* docs\n\n\u0026lt;manually download and fixup the _template.html\u0026gt;\n\ndotnet fsdocs watch\n\ntouch docs/_template.fsx\ntouch docs/_template.ipynb\ngit add docs/_template.fsx\ngit add docs/_template.ipynb\n\nHere is an example PR: https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116\n","headings":["Upgrading to fsdocs"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/styling.html","title":"Customization and Styling\n","content":"\nCustomization and Styling\nWhen using fsdocs, there are six levels of extra content development and styling.\n\n\nDon\u0027t do any styling or documentation customization and simply write content. This is by far the simplest option to\nmaintain.\n\n\nAdd content such as an docs/index.md to customize the front-page content for your generated docs.\nYou can also add content such as docs/reference/fslib.md to give a bespoke landing page\nfor one of your namespaces, e.g. here assumed to be namespace FsLib. This will override any\ngenerated content.\n\nCustomize via Styling Parameters\nCustomize via CSS\nCustomize via a new template\nCustomize by generating your own site using your own code\n\nBy default fsdocs does no styling customization and uses the following defaults. These are the settings used to build\nthis site.\n\n\nUses the default template\nin docs/_template.html\n\n\nUses the default styles\nin docs/content/fsdocs-default.css.\n\n\nUses no custom styles\nin docs/content/fsdocs-custom.css.\n\nUses no styling parameters except those extracted from the project files.\n\nFor your project, you don\u0027t need any of these files. However you can add them if you wish, though if\nyou adjust them there is no guarantee that your template will continue to work with future versions of F# Formatting.\nCustomizing via Styling Parameters\nThe following content parameters are particularly related to visual styling:\n\n\n\nSubstitution name\nValue (if not overriden by --parameters)\n\n\n\n\nfsdocs-authors\n\u0026lt;Authors\u0026gt;\n\n\nfsdocs-license-link\n\u0026lt;FsDocsLicenseLink\u0026gt;\n\n\nfsdocs-logo-src\n\u0026lt;FsDocsLogoSource\u0026gt;\n\n\nfsdocs-favicon-src\n\u0026lt;FsDocsFaviconSource\u0026gt;\n\n\nfsdocs-logo-link\n\u0026lt;FsDocsLogoLink\u0026gt;\n\n\nfsdocs-release-notes-link\n\u0026lt;FsDocsReleaseNotesLink\u0026gt; else \u0026lt;PackageProjectUrl\u0026gt;/blob/master/RELEASE_NOTES.md\n\n\nfsdocs-repository-link\n\u0026lt;RepositoryUrl\u0026gt;\n\n\nfsdocs-theme\n\u0026lt;FsDocsTheme\u0026gt;, must currently be default\n\n\n\n\nThese basic entry-level styling parameters can be set in the project file or Directory.Build.props.\nFor example:\n\u0026lt;PropertyGroup\u0026gt;\n \u0026lt;!-- Example ultra-simple styling and generation settings for FsDocs default template--\u0026gt;\n \u0026lt;PackageLicenseUrl\u0026gt;https://github.com/foo/bar/blob/master/License.txt\u0026lt;/PackageLicenseUrl\u0026gt;\n \u0026lt;PackageProjectUrl\u0026gt;https://foo.github.io/bar/\u0026lt;/PackageProjectUrl\u0026gt;\n \u0026lt;RepositoryUrl\u0026gt;https://github.com/foo/bar/\u0026lt;/RepositoryUrl\u0026gt;\n \u0026lt;FsDocsLogoLink\u0026gt;https://fsharp.org\u0026lt;/FsDocsLogoLink\u0026gt;\n \u0026lt;FsDocsLogoSource\u0026gt;img/logo.png\u0026lt;/FsDocsLogoSource\u0026gt;\n \u0026lt;FsDocsFaviconSource\u0026gt;img/favicon.ico\u0026lt;/FsDocsFaviconSource\u0026gt;\n \u0026lt;FsDocsLicenseLink\u0026gt;https://github.com/foo/bar/blob/master/License.txt\u0026lt;/FsDocsLicenseLink\u0026gt;\n \u0026lt;FsDocsReleaseNotesLink\u0026gt;https://github.com/foo/bar/blob/master/release-notes.md\u0026lt;/FsDocsReleaseNotesLink\u0026gt;\n \u0026lt;FsDocsWarnOnMissingDocs\u0026gt;true\u0026lt;/FsDocsWarnOnMissingDocs\u0026gt;\n \u0026lt;FsDocsTheme\u0026gt;default\u0026lt;/FsDocsTheme\u0026gt;\n\u0026lt;/PropertyGroup\u0026gt;\n\nAs an example, here is a page with alternative styling.\nCustomizing via CSS\nYou can start styling by creating a file docs/content/fsdocs-theme.css and adding entries to it.\nIt is loaded by the standard template.\nCSS variables\nThe default template is heavily based\non CSS variables. These can easily be\noverride to customize the look and feel of the default theme.\nA full list of the overrideable variables can be\nfound here.\n:root {\n --text-color: red;\n}\n\n[data-theme=dark] {\n --text-color: darkred;\n}\n\nPlease be aware that the dark mode in the default theme is using the same variables.\nWhen you override a variable, it will also be used in dark mode unless redefined in a [data-theme=dark] CSS query.\nCSS classes\nThe API documentation uses a set of fixed CSS classes:\n\n\n\nCSS class\nCorresponding Content\n\n\n\n\n.fsdocs-tip\ngenerated tooltips\n\n\n.fsdocs-xmldoc\ngenerated xmldoc sections\n\n\n.fsdocs-member-list\ngenerated member lists (tables)\n\n\n.fsdocs-member-usage\nusage in generated member lists\n\n\n.fsdocs-member-tooltip\ntooltips in generated member lists\n\n\n.fsdocs-member-xmldoc\ndocumentation in generated member lists\n\n\n.fsdocs-entity-list\ngenerated entity lists\n\n\n.fsdocs-entity-name\ngenerated entity lists\n\n\n.fsdocs-entity-xmldoc\ndocumentation in generated entity lists\n\n\n.fsdocs-exception-list\ngenerated exception lists\n\n\n.fsdocs-summary\nthe \u0027summary\u0027 section of an XML doc\n\n\n.fsdocs-remarks\nthe \u0027remarks\u0027 section of an XML doc\n\n\n.fsdocs-params\nthe \u0027parameters\u0027 section of an XML doc\n\n\n.fsdocs-param\na \u0027parameter\u0027 section of an XML doc\n\n\n.fsdocs-param-name\na \u0027parameter\u0027 name of an XML doc\n\n\n.fsdocs-returns\nthe \u0027returns\u0027 section of an XML doc\n\n\n.fsdocs-example\nthe \u0027example\u0027 section of an XML doc\n\n\n.fsdocs-note\nthe \u0027notes\u0027 section of an XML doc\n\n\n.fsdocs-para\na paragraph of an XML doc\n\n\n\n\nSome generated elements are given specific HTML ids:\n\n\n\nHTML element selector\nContent\n\n\n\n\nheader\nThe navigation-bar\n\n\n#fsdocs-main-menu\nThe main menu on the left side\n\n\n#content\nThe generated content\n\n\n#fsdocs-page-menu\nThe sub menu on the right side\n\n\ndialog\nThe search dialog\n\n\ndialog input[type=search]\nThe search box\n\n\n#fsdocs-logo\nThe logo\n\n\n\n\nIf you write a new theme by CSS styling please contribute it back to FSharp.Formatting.\nCustomizing via a new template\nYou can do advanced styling by creating a new template. Add a file docs/_template.html, likely starting\nwith the existing default template.\n\nNOTE: To enable hot reload during development with fsdocs watch in a custom _template.html file,\nmake sure to add the single line {{fsdocs-watch-script}} to your \u0026lt;head\u0026gt; tag.\nNOTE: There is no guarantee that your template will continue to work with future versions of F# Formatting.\nIf you do develop a good template please consider contributing it back to F# Formatting.\n\nCustomizing menu items by template\nYou can add advanced styling to the sidebar generated menu items by creating a new template for it.\nfsdoc will look for menu templates in the --input folder which defaults to the docs folder.\nTo customize the generated menu-item headers, use file _menu_template.html with starting template:\n\u0026lt;li class=\u0022nav-header\u0022\u0026gt;\n {{fsdocs-menu-header-content}}\n\u0026lt;/li\u0026gt;\n{{fsdocs-menu-items}}\n\nSimilarly, to customize the individual menu item list, use file _menu-item_template.html with starting template:\n\u0026lt;li class=\u0022nav-item\u0022\u0026gt;\u0026lt;a href=\u0022{{fsdocs-menu-item-link}}\u0022 class=\u0022nav-link\u0022\u0026gt;{{fsdocs-menu-item-content}}\u0026lt;/a\u0026gt;\u0026lt;/li\u0026gt;\n\nDo note that files need to be added prior running or won\u0027t be generated.\nIn case you want to get a unique identifier for a header or menu item, you can use {{fsdocs-menu-header-id}}\nand {{fsdocs-menu-item-id}}, respectively.\nInjecting additional html into the default template\nOccasionally, you may find the need to make small customizations to the default template, such as adding a Google\nAnalytics snippet or including additional style or script tags. To address this scenario, you can create two\nfiles: _head.html and/or _body.html.\nThe content within these files will serve as replacements for the {{fsdocs-head-extra}} and {{fsdocs-body-extra}}\nplaceholders, which are utilized in the default template.\nCustomizing by generating your own site using your own code\nThe FSharp.Formatting.ApiDocs namespace includes a GenerateModel that captures\nthe results of documentation preparation in ApiDocsModel and allows you to\ngenerate your own site using your own code.\n\nNOTE: The ApiDocsModel API is undergoing change and improvement and there is no guarantee that your bespoke site\ngeneration will continue to work\nwith future versions of F# Formatting.\nNOTE: The ApiDocsModel currently includes some generated HTML with some specific style tags.\nIn the long term these may be removed from the design of that component.\n\n","headings":["Customization and Styling","Customizing via Styling Parameters","Customizing via CSS","CSS variables","CSS classes","Customizing via a new template","Customizing menu items by template","Injecting additional html into the default template","Customizing by generating your own site using your own code"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/markdown.html","title":"Markdown parser\n","content":"\n\u0026emsp;\n\u0026emsp;\n\nMarkdown parser\nThis page demonstrates how to use FSharp.Formatting.Markdown to parse a Markdown\ndocument, process the obtained document representation and\nhow to turn the code into a nicely formatted HTML.\nFirst, we need to load the assembly and open necessary namespaces:\nopen FSharp.Formatting.Markdown\nopen FSharp.Formatting.Common\n\nParsing documents\nThe F# Markdown parser recognizes the standard Markdown syntax\nand it is not the aim of this tutorial to fully document it.\nThe following snippet creates a simple string containing a document\nwith several elements and then parses it using the Markdown.Parse method:\nlet document =\n \u0026quot;\u0026quot;\u0026quot;\n# F# Hello world\nHello world in [F#](http://fsharp.net) looks like this:\n\n printfn \u0026quot;Hello world!\u0026quot;\n\nFor more see [fsharp.org][fsorg].\n\n [fsorg]: http://fsharp.org \u0026quot;The F# organization.\u0026quot; \u0026quot;\u0026quot;\u0026quot;\n\nlet parsed = Markdown.Parse(document)\n\nThe sample document consists of a first-level heading (written using\none of the two alternative styles) followed by a paragraph with a\ndirect link, code snippet and one more paragraph that includes an\nindirect link. The URLs of indirect links are defined by a separate\nblock as demonstrated on the last line (and they can then be easily used repeatedly\nfrom multiple places in the document).\nWorking with parsed documents\nThe F# Markdown processor does not turn the document directly into HTML.\nInstead, it builds a nice F# data structure that we can use to analyze,\ntransform and process the document. First of all the MarkdownDocument.DefinedLinks property\nreturns all indirect link definitions:\nparsed.DefinedLinks\nval it : IDictionary\u0026lt;string,(string * string option)\u0026gt; =\n dict [(\u0026quot;fsorg\u0026quot;, (\u0026quot;http://fsharp.org\u0026quot;, Some \u0026quot;The F# organization.\u0026quot;))]\n\nThe document content can be accessed using the MarkdownDocument.Paragraphs property that returns\na sequence of paragraphs or other first-level elements (headings, quotes, code snippets, etc.).\nThe following snippet prints the heading of the document:\n// Iterate over all the paragraph elements\nfor par in parsed.Paragraphs do\n match par with\n | Heading (size = 1; body = [ Literal (text = text) ]) -\u0026gt;\n // Recognize heading that has a simple content\n // containing just a literal (no other formatting)\n printfn \u0026quot;%s\u0026quot; text\n | _ -\u0026gt; ()\n\nYou can find more detailed information about the document structure and how to process it\nin the book F# Deep Dives.\nProcessing the document recursively\nThe library provides active patterns that can be used to easily process the Markdown\ndocument recursively. The example in this section shows how to extract all links from the\ndocument. To do that, we need to write two recursive functions. One that will process\nall paragraph-style elements and one that will process all inline formattings (inside\nparagraphs, headings etc.).\nTo avoid pattern matching on every single kind of span and every single kind of\nparagraph, we can use active patterns from the MarkdownPatterns module. These can be use\nto recognize any paragraph or span that can contain child elements:\n/// Returns all links in a specified span node\nlet rec collectSpanLinks span =\n seq {\n match span with\n | DirectLink (link = url) -\u0026gt; yield url\n | IndirectLink (key = key) -\u0026gt; yield fst (parsed.DefinedLinks.[key])\n | MarkdownPatterns.SpanLeaf _ -\u0026gt; ()\n | MarkdownPatterns.SpanNode (_, spans) -\u0026gt;\n for s in spans do\n yield! collectSpanLinks s\n }\n\n/// Returns all links in the specified paragraph node\nlet rec collectParLinks par =\n seq {\n match par with\n | MarkdownPatterns.ParagraphLeaf _ -\u0026gt; ()\n | MarkdownPatterns.ParagraphNested (_, pars) -\u0026gt;\n for ps in pars do\n for p in ps do\n yield! collectParLinks p\n | MarkdownPatterns.ParagraphSpans (_, spans) -\u0026gt;\n for s in spans do\n yield! collectSpanLinks s\n }\n\n// Collect links in the entire document\nSeq.collect collectParLinks parsed.Paragraphs\nval it : seq\u0026lt;string\u0026gt; =\n seq [\u0026quot;http://fsharp.net\u0026quot;; \u0026quot;http://fsharp.org\u0026quot;]\n\nThe collectSpanLinks function works on individual span elements that contain inline\nformatting (emphasis, strong) and also links. The DirectLink node from MarkdownSpan represents an inline\nlink like the one pointing to http://fsharp.net while IndirectLink represents a\nlink that uses one of the link definitions. The function simply returns the URL associated\nwith the link.\nSome span nodes (like emphasis) can contain other formatting, so we need to recursively\nprocess children. This is done by matching against MarkdownPatterns.SpanNodes which is an active\npattern that recognizes any node with children. The library also provides a function\nnamed MarkdownPatterns.SpanNode that can be used to reconstruct the same node (when you want\nto transform document). This is similar to how the ExprShape module for working with\nF# quotations works.\nThe function collectParLinks processes paragraphs - a paragraph cannot directly be a\nlink so we just need to process all spans. This time, there are three options.\nParagraphLeaf represents a case where the paragraph does not contain any spans\n(a code block or, for example, a \u0026lt;hr\u0026gt; line); the ParagraphNested case is used for paragraphs\nthat contain other paragraphs (quotation) and ParagraphSpans is used for all other\nparagraphs that contain normal text - here we call collectSpanLinks on all nested spans.\nGenerating HTML output\nFinally, the Markdown type also includes a method Markdown.ToHtml that can be used\nto generate an HTML document from the Markdown input. The following example shows how to call it:\nlet html = Markdown.ToHtml(parsed)\n\nThere are also methods to generate .fsx, .ipynb, .md and .tex.\n","headings":["Markdown parser","Parsing documents","Working with parsed documents","Processing the document recursively","Generating HTML output"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/literate-notebook.html","title":"Literate Notebooks\n","content":"\nLiterate Notebooks\nContent may be created using .NET interactive polyglot notebooks as the input file. Notebooks are processed by converting the notebook to a literate .fsx script and then passing the script through the script processing pipeline. Markdown notebook cells are passed through as comments surrounded by (** and *), F# code cells are passed through as code, and non-F# code is passed through as markdown fenced code blocks between (** and *) comment markers.\nThe fsdocs tool uses dotnet-repl to evaluate polyglot notebooks. You need this tool to evaluate notebooks using dotnet fsdocs [build|watch] --eval. It can be installed into your local tool manifest using the command dotnet tool install dotnet-repl.\nF# Formatting tries to faithfully reproduce a notebook\u0027s native appearance when generating documents. Notebook cell outputs are passed through unchanged to preserve the notebook\u0027s html output. The below snippet demonstrates a notebook\u0027s html output for F# records, which differs from the output you would get with the same code inside a literate scripts.\ntype ContactCard =\n { Name: string\n Phone: string\n ZipCode: string }\n\n// Create a new record\n{ Name = \u0026quot;Alf\u0026quot;; Phone = \u0026quot;(555) 555-5555\u0026quot;; ZipCode = \u0026quot;90210\u0026quot; }\n\n{ Name = \u0026quot;Alf\u0026quot;\\n Phone = \u0026quot;(555) 555-5555\u0026quot;\\n ZipCode = \u0026quot;90210\u0026quot; }NameAlfPhone(555) 555-5555ZipCode90210\n.dni-code-hint {\n font-style: italic;\n overflow: hidden;\n white-space: nowrap;\n}\n.dni-treeview {\n white-space: nowrap;\n}\n.dni-treeview td {\n vertical-align: top;\n text-align: start;\n}\ndetails.dni-treeview {\n padding-left: 1em;\n}\ntable td {\n text-align: start;\n}\ntable tr { \n vertical-align: top; \n margin: 0em 0px;\n}\ntable tr td pre \n{ \n vertical-align: top !important; \n margin: 0em 0px !important;\n} \ntable th {\n text-align: start;\n}\n\n\n","headings":["Literate Notebooks"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/content.html","title":"Creating Content\n","content":"\n\u0026emsp;\n\u0026emsp;\n\nCreating Content\nThe \u0022fsdocs\u0022 tool allows documentation for a site to be built\nfrom content in a docs directory. The expected structure for a docs directory is\ndocs/**/*.md -- markdown with embedded code, converted to html and optionally tex/ipynb\ndocs/**/*.fsx -- fsx scripts converted to html and optionally tex/ipynb\ndocs/**/* -- other content, copied over\ndocs/**/_template.html -- optional template, specifies the HTML template for this directory and its contents\ndocs/**/_template.tex -- optionally indicates Latex files should be generated\ndocs/**/_template.ipynb -- optionally indicates F# ipynb files should be generated\ndocs/**/_template.fsx -- optionally indicates F# fsx files should be generated (even from markdown)\ndocs/reference/_template.html -- optionally specifies the default template for reference docs\n\nProcessing is by these two commands:\ndotnet fsdocs build\ndotnet fsdocs watch\n\nThe output goes in output/ by default. Processing is recursive, making this a form of static site generation.\nLiterate Scripts and Markdown Content\nThe input directory may contain literate scripts and markdown content.\nOther Content\nContent that is not *.fsx or *.md is copied across.\nDefault Styling Content\nBy default additional content such as fsdocs-search.js, fsdocs-tips.js and fsdocs-default.css are included in the\nthe content directory of the output. This can be suppressed with --nodefaultcontent or by having your own\ncopy of this content in your content directory.\nIgnored Content\nAny file or directory beginning with . is ignored.\nFront matter\nEach content file can have optional frontmatter. This determines the navigation bar title, categorization ordering and meta tags.\nFor markdown, the format is:\n---\ntitle: Some Title\ncategory: Some Category\ncategoryindex: 2\nindex: 3\ndescription: Some description\nkeywords: tag1, tag2, tag3\n---\n\nFor F# scripts the frontmatter is in this form:\n(**\n---\ntitle: A Literate Script\ncategory: Examples\ncategoryindex: 2\nindex: 1\ndescription: Some description\nkeywords: tag1, tag2, tag3\n---\n*)\n\nAll entries are optional.\nThe categoryindex determines the ordering of categories.\nThe index determines the ordering of within each category.\nThe title is used in the navigation bar instead of any title inferred from the document.\nThe description is used in \u0026lt;meta name=\u0022description\u0022 as part of the {{fsdocs-meta-tags}} substitution.\nThe keywords are also used in a meta tag as part of {{fsdocs-meta-tags}}. Separate them using a ,.\nLink Translation for Inputs\nIf an input is used in markdown as a target of a markdown direct link then that is replaced by the output file. For example:\n[Some Text](some-file.md)\n\nbecomes\n[Some Text](some-file.html)\n\nif some-file.md is one of the inputs.\nMulti-language Content\nVersions of content in other languages should go in two-letter coded sub-directories, e.g.\ndocs/ja/...\ndocs/de/...\n\nThese will be elided from the main table-of-contents and search indexes. (Currently no language-specific\ntable of contents is built, nor language-specific site search indexes).\nTemplates and Substitutions\nTemplates are used for HTML (_template.html), LaTeX (_template.tex), Notebooks (_template.ipynb)\nand F# script outputs (_template.fsx).\nThe following substitutions determine the primary (non-styling) content of your site.\nFor example {{fsdocs-content}} is replaced with the generated content in each file.\nSubstitutions are applied when generating content from HTML templates, IPYNB templates, FSX templates.\nThey are also applied to content apart from Markdown inline code \u0060...\u0060, Markdown LaTeX and\ngenerated outputs.\nSee Styling for information about template parameters and styling beyond the default template.\n\n\n\nSubstitution name\nGenerated content\n\n\n\n\nroot\n\u0026lt;PackageProjectUrl\u0026gt; else / followed by fsdocs-collection-name\n\n\nfsdocs-collection-name\nName of .sln, single .fsproj or containing directory\n\n\nfsdocs-content\nMain page content\n\n\nfsdocs-list-of-namespaces\nHTML \u0026lt;li\u0026gt; list of namespaces with links\n\n\nfsdocs-list-of-documents\nHTML \u0026lt;li\u0026gt; list of documents with titles and links\n\n\nfsdocs-page-title\nFirst h1 heading in literate file. Generated for API docs\n\n\nfsdocs-source\nOriginal literate script or markdown source\n\n\nfsdocs-source-filename\nName of original input source, relative to the docs root\n\n\nfsdocs-source-basename\nName of original input source, excluding its extensions, relative to the docs root\n\n\nfsdocs-tooltips\nGenerated hidden div elements for tooltips\n\n\nfsdocs-watch-script\nThe websocket script used in watch mode to trigger hot reload\n\n\nfsdocs-previous-page-link\nA relative link to the previous page based on the frontmatter index data\n\n\nfsdocs-next-page-link\nA relative link to the next page based on the frontmatter index data\n\n\nfsdocs-head-extra\nAdditional html content loaded from the _head.html file if present in the --input folder\n\n\nfsdocs-body-extra\nAdditional html content loaded from the _body.html file if present in the --input folder\n\n\nfsdocs-body-class\nA css class value to help distinguish between content and api-docs\n\n\nfsdocs-meta-tags\nA set of additional HTML meta tags, present when description and/or keywords are present in the frontmatter\n\n\n\n\nThe following substitutions are extracted from your project files and may or may not be used by the default\ntemplate:\n\n\n\nSubstitution name\nValue\n\n\n\n\nfsdocs-copyright\n\u0026lt;Copyright\u0026gt;\n\n\nfsdocs-package-project-url\n\u0026lt;PackageProjectUrl\u0026gt;\n\n\nfsdocs-package-license-expression\n\u0026lt;PackageLicenseExpression\u0026gt;\n\n\nfsdocs-package-tags\n\u0026lt;PackageTags\u0026gt;\n\n\nfsdocs-package-version\n\u0026lt;Version\u0026gt;\n\n\n\n\nFor the fsdocs tool, additional substitutions can be specified using --parameters.\nCross References to API Docs\nMarkdown content can contain cross-references to API Docs. Use inline\nmarkdown code snippets of the special form \u0060cref:T:MyNamespace.MyType\u0060 where T:MyNamespace.MyType\nis a method, property or type xml doc sig reference, see API Docs.\nThis can include any cross-references resolved by fsdocs.\nThe generated API documentation includes buttons to copy the XML and Markdown forms of API doc references.\nFor example, within this project,\n\nthe text \u0060cref:T:FSharp.Formatting.Markdown.MarkdownParagraph\u0060 resolves to the link MarkdownParagraph\nthe text \u0060cref:T:System.Console\u0060 resolves to the link Console\nthe text \u0060cref:M:System.Console.WriteLine\u0060 resolves to the link Console.WriteLine\nthe text \u0060cref:M:System.Console.WriteLine(System.String)\u0060 resolves to the link Console.WriteLine\nthe text \u0060\u0060cref:T:FSharp.Control.FSharpAsync\u00601\u0060\u0060 resolves to the link Async\nthe text \u0060cref:T:FSharp.Control.FSharpAsync\u0060 resolves to the link Async\nthe text \u0060\u0060cref:T:FSharp.Core.array\u00601\u0060\u0060 resolves to the link array\nthe text \u0060cref:T:FSharp.Core.OptionModule\u0060 resolves to the link Option\nthe text \u0060\u0060\u0060cref:M:FSharp.Collections.ListModule.Append\u0060\u00601\u0060\u0060\u0060 resolves to the link ListModule.Append\n\n\nNOTE: These cases act as tests - if the links above do not work, then that indicates a bug or a change in the\nexternal link. Please report it.\n\nDetermining xmldoc sig references is not simple. The API doc generated pages come with\nbuttons to copy out the XmlDoc signature.\nGenerating HTML Output\nHTML is generated by default. You can also add a _template.html. This should contain {{fsdocs-content}}, {{fsdocs-tooltips}}\nand other placeholders. Substitutions are\napplied to this template.\nIf a file _template.html exists then is used as the template for HTML generation for that directory and all sub-content.\nGenerating LaTeX output\nTo generate .tex output for each script and markdown file, add a _template.tex. Substitutions are\napplied to this template. The file is either empty of contains {{fsdocs-content}} as the key where the body\nof the document is placed.\nGenerating iPython Notebook output\nTo generate .ipynb output for each script and markdown file, add a _template.ipynb, usually empty. Substitutions are\napplied to this template.\nTo add a mybinder badge to your generated notebook, ensure you have a Dockerfile and NuGet.config\nin your docs directory and use text like this:\n[](https://mybinder.org/v2/gh/fsprojects/FSharp.Formatting/gh-pages?filepath=literate.ipynb)\n\nGenerating Script outputs\nTo generate .fsx output for each script and markdown file, add a _template.fsx, usually empty. Substitutions are\napplied to this template. It is either empty of contains {{fsdocs-content}} as the key where the body\nof the script is placed.\n","headings":["Creating Content","Literate Scripts and Markdown Content","Other Content","Default Styling Content","Ignored Content","Front matter","Link Translation for Inputs","Multi-language Content","Templates and Substitutions","Cross References to API Docs","Generating HTML Output","Generating LaTeX output","Generating iPython Notebook output","Generating Script outputs"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/evaluation.html","title":"Embedding script output\n","content":"\n\u0026emsp;\n\u0026emsp;\n\nEmbedding script output\nFor literate F# scripts, you may embed the result of running the script as part of the literate output.\nThis is a feature of the functions discussed in literate programming and\nit is implemented using the F# Compiler service.\nIncluding Console Output\nTo include the Console output use include-output:\nlet test = 40 \u002B 2\n\nprintf \u0026quot;A result is: %d\u0026quot; test\n(*** include-output ***)\n\nThe script defines a variable test and then prints it. The console output is included\nin the output.\nTo include the a formatted value use include-it:\n[ 0 .. 99 ]\n\n(*** include-it ***)\n\nTo include the meta output of F# Interactive processing such as type signatures use (*** include-fsi-output ***):\nlet test = 40 \u002B 3\n\n(*** include-fsi-output ***)\n\nTo include both console otuput and F# Interactive output blended use (*** include-fsi-merged-output ***).\nlet test = 40 \u002B 4\n(*** include-fsi-merged-output ***)\n\nYou can use the same commands with a named snippet:\n(*** include-it: test ***)\n(*** include-fsi-output: test ***)\n(*** include-output: test ***)\n\nYou can use the include-value command to format a specific value:\nlet value1 = [ 0 .. 50 ]\nlet value2 = [ 51 .. 100 ]\n(*** include-value: value1 ***)\n\nUsing AddPrinter and AddHtmlPrinter\nYou can use fsi.AddPrinter, fsi.AddPrintTransformer and fsi.AddHtmlPrinter to extend the formatting of objects.\nEmitting Raw Text\nTo emit raw text in F# literate scripts use the following:\n(**\n\t(*** raw ***)\n\tSome raw text.\n*)\n\nwhich would emit\n\nSome raw text.\n\ndirectly into the document.\nF# Formatting as a Library: Specifying the Evaluator and Formatting\nIf using F# Formatting as a library the embedding of F# output requires specifying an additional parameter to the\nparsing functions discussed in literate programming documentation.\nAssuming you have all the references in place, you can now create an instance of\nFsiEvaluator that represents a wrapper for F# interactive and pass it to all the\nfunctions that parse script files or process script files:\nopen FSharp.Formatting.Literate\nopen FSharp.Formatting.Literate.Evaluation\nopen FSharp.Formatting.Markdown\n\n// Sample literate content\nlet content =\n \u0026quot;\u0026quot;\u0026quot;\nlet a = 10\n(*** include-value:a ***)\u0026quot;\u0026quot;\u0026quot;\n\n// Create evaluator and parse script\nlet fsi = FsiEvaluator()\n\nlet doc = Literate.ParseScriptString(content, fsiEvaluator = fsi)\n\nLiterate.ToHtml(doc)\n\nWhen the fsiEvaluator parameter is specified, the script is evaluated and so you\ncan use additional commands such as include-value. When the evaluator is not specified,\nit is not created automatically and so the functionality is not available (this way,\nyou won\u0027t accidentally run unexpected code!)\nIf you specify the fsiEvaluator parameter, but don\u0027t want a specific snippet to be evaluated\n(because it might throw an exception, for example), you can use the (*** do-not-eval ***)\ncommand.\nThe constructor of FsiEvaluator takes command line parameters for fsi.exe that can\nbe used to specify, for example, defined symbols and other attributes for F# Interactive.\nYou can also subscribe to the EvaluationFailed event which is fired whenever the evaluation\nof an expression fails. You can use that to do tests that verify that all off the code in your\ndocumentation executes without errors.\nF# Formatting as a Library: Custom formatting functions\nAs mentioned earlier, values are formatted using a simple \u0022%A\u0022 formatter by default.\nHowever, you can specify a formatting function that provides a nicer formatting for values\nof certain types. For example, let\u0027s say that we would want to format F# lists such as\n[1; 2; 3] as HTML ordered lists \u0026lt;ol\u0026gt;.\nThis can be done by calling FsiEvaluator.RegisterTransformation on the FsiEvaluator instance:\n// Create evaluator \u0026amp; register simple formatter for lists\nlet fsiEvaluator = FsiEvaluator()\n\nfsiEvaluator.RegisterTransformation(fun (o, ty, _executionCount) -\u0026gt;\n // If the type of value is an F# list, format it nicely\n if ty.IsGenericType\n \u0026amp;\u0026amp; ty.GetGenericTypeDefinition() = typedefof\u0026lt;list\u0026lt;_\u0026gt;\u0026gt; then\n let items =\n // Get items as objects and create paragraph for each item\n [ for it in Seq.cast\u0026lt;obj\u0026gt; (unbox o) -\u0026gt; [ Paragraph([ Literal(it.ToString(), None) ], None) ] ]\n // Return option value (success) with ordered list\n Some [ ListBlock(MarkdownListKind.Ordered, items, None) ]\n else\n None)\n\nThe function is called with two arguments - o is the value to be formatted and ty\nis the static type of the value (as inferred by the F# compiler). The sample checks\nthat the type of the value is a list (containing values of any type) and then it\ncasts all values in the list to obj (for simplicity). Then we generate Markdown\nblocks representing an ordered list. This means that the code will work for both\nLaTeX and HTML formatting - but if you only need one, you can simply produce HTML and\nembed it in InlineHtmlBlock.\nTo use the new FsiEvaluator, we can use the same style as earlier. This time, we format\na simple list containing strings:\nlet listy =\n \u0026quot;\u0026quot;\u0026quot;\n### Formatting demo\nlet test = [\u0026quot;one\u0026quot;;\u0026quot;two\u0026quot;;\u0026quot;three\u0026quot;]\n(*** include-value:test ***)\u0026quot;\u0026quot;\u0026quot;\n\nlet docOl = Literate.ParseScriptString(listy, fsiEvaluator = fsiEvaluator)\n\nLiterate.ToHtml(docOl)\n\nThe resulting HTML formatting of the document contains the snippet that defines test,\nfollowed by a nicely formatted ordered list:\n\nFormatting demo\n\n1: \n\n\n\nlet test = [\u0026quot;one\u0026quot;;\u0026quot;two\u0026quot;;\u0026quot;three\u0026quot;]\n\n\n\n\none\ntwo\nthree\n\n\n","headings":["Embedding script output","Including Console Output","Using AddPrinter and AddHtmlPrinter","Emitting Raw Text","F# Formatting as a Library: Specifying the Evaluator and Formatting","F# Formatting as a Library: Custom formatting functions"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/commandline.html","title":"Command line\n","content":"\nCommand line\nTo use F# Formatting tools via the command line, you can use the fsdocs dotnet tool.\ndotnet tool install fsdocs-tool\ndotnet fsdocs [command] [options]\n\nThe build command\nThis command processes a docs directory and generates API docs for projects in the solution according to the\nrules of API doc generation. The input accepted is described in content.\nfsdocs build\n\nThe command line options accepted are:\n\n\n\nCommand Line Option\nDescription\n\n\n\n\n--input\nInput directory of content (default: docs)\n\n\n--projects\nProject files to build API docs for outputs, defaults to all packable projects\n\n\n--output\nOutput Directory (default \u0027output\u0027 for \u0027build\u0027 and \u0027tmp/watch\u0027 for \u0027watch\u0027)\n\n\n--noapidocs\nDisable generation of API docs\n\n\n--ignoreprojects\nDisable project cracking\n\n\n--eval\nEvaluate F# fragments in scripts\n\n\n--saveimages\nSave images referenced in docs\n\n\n--nolinenumbers\nDon\u0027t add line numbers, default is to add line number.\n\n\n--parameters\nAdditional substitution parameters for templates\n\n\n--nonpublic\nThe tool will also generate documentation for non-public members\n\n\n--nodefaultcontent\nDo not copy default content styles, javascript or use default templates\n\n\n--clean\nClean the output directory\n\n\n--help\nDisplay this help screen\n\n\n--version\nDisplay version information\n\n\n--properties\nProvide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4\n\n\n--fscoptions\nAdditional arguments passed down as otherflags to the F# compiler when the API is being generated.Note that these arguments are trimmed, this is to overcome a limitation in the command line argument processing.A typical use-case would be to pass an addition assembly reference.Example --fscoptions \u0022 -r:MyAssembly.dll\u0022\n\n\n--strict\nFail if docs are missing or can\u0027t be generated\n\n\n\n\nThe following command line options are also accepted but it is instead recommended you use\nsettings in your .fsproj project files:\n\n\n\nCommand Line Option\nDescription\n\n\n\n\n--sourcefolder\nSource folder at time of component build (\u0026lt;FsDocsSourceFolder\u0026gt;)\n\n\n--sourcerepo\nSource repository for github links (\u0026lt;FsDocsSourceRepository\u0026gt;)\n\n\n--mdcomments\nAssume comments in F# code are markdown (\u0026lt;UsesMarkdownComments\u0026gt;)\n\n\n\n\nThe command will report on any .fsproj files that it finds, telling you if it decides to skip a particular file and why.\nFor example, a project will be skipped if:\n\nThe project name contains \u0022.Tests\u0022 or \u0022test\u0022 (because it looks like a test project)\n\nThe project does not contain\n\u0026lt;GenerateDocumentationFile\u0026gt;true\u0026lt;/GenerateDocumentationFile\u0026gt;\n\n\n\nThe watch command\nThis command does the same as fsdocs build but in \u0022watch\u0022 mode, waiting for changes. Only the files in the input\ndirectory (e.g. docs) are watched. A browser will be launched automatically (unless --nolaunch is specified).\nYou will need to ensure that the input directory exists, and contains at least index.md, otherwise the browser will\nreport an error (e.g. \u0022Problem loading...\u0022, \u0022Connection was reset\u0022).\nfsdocs watch\n\nRestarting may be necesssary on changes to project files. The same parameters are accepted, plus these:\n\n\n\nCommand Line Option\nDescription\n\n\n\n\n--noserver\nDo not serve content when watching.\n\n\n--nolaunch\nDo not launch a browser window.\n\n\n--open\nURL extension to launch http://localhost:/%s.\n\n\n--port\nPort to serve content for http://localhost serving.\n\n\n\n\nSearchable docs\nWhen using the command-line tool a Fuse search index is automatically generated in index.json.\nA search box is included in the default template via an HTML Dialog element.\nTo add search to your own _template.html:\n\ninclude an HTML element with id search-btn\ninclude a dialog element\ninclude fsdocs-search.js script\n\n\u0026lt;button id=\u0022search-btn\u0022\u0026gt;Open search dialog\u0026lt;/button\u0026gt;\n\u0026lt;dialog\u0026gt;\n \u0026lt;input type=\u0022search\u0022 placeholder=\u0022Search docs\u0022 /\u0026gt;\n \u0026lt;div class=\u0022results\u0022\u0026gt;\n \u0026lt;ul\u0026gt;\u0026lt;/ul\u0026gt;\n \u0026lt;p class=\u0022empty\u0022\u0026gt;Type something to start searching.\u0026lt;/p\u0026gt;\n \u0026lt;/div\u0026gt;\n\u0026lt;/dialog\u0026gt;\n\u0026lt;script type=\u0022module\u0022 src=\u0022{\u0060{root}}content/fsdocs-search.js\u0022\u0026gt;\u0026lt;/script\u0026gt;\n\n","headings":["Command line","The build command","The watch command","Searchable docs"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/users.html","title":"Users of FSharp.Formatting\n","content":"\nUsers of FSharp.Formatting\nThe FSharp.Formatting documentation tool is widely used within the F# community.\nHere is a non-exhaustive list of projects:\n\n\ntable { table-layout: fixed; }\ntr td { padding: 15px 0; }\ntr td p { margin: 0 }\ntr th:first-child, tr td:first-child { width: 20%; }\ntr th:last-child, tr td:last-child { width: 35% }\n\n\n\n\nProject name\n\nRepository\nNote\n\n\n\n\nFSharp.Formatting\n\nhttps://github.com/fsprojects/FSharp.Formatting/\n\n\n\nF# compiler guide\n\nhttps://github.com/dotnet/fsharp/\nThe documentation is generated and published from https://github.com/fsharp/fsharp-compiler-docs\n\n\nF# Core Library Documentation\n\nhttps://github.com/dotnet/fsharp/\nThe documentation is generated and published from https://github.com/fsharp/fsharp-core-docs\n\n\nFsLexYacc\n\nhttps://github.com/fsprojects/fslexYacc/\n\n\n\nFSharp.Data\n\nhttps://github.com/fsprojects/FSharp.Data/\n\n\n\nPlotly.NET\n\nhttps://github.com/plotly/Plotly.NET\n\n\n\nFSharp.Stats\n\nhttps://github.com/fslaborg/FSharp.Stats/\n\n\n\nFsHttp\n\nhttps://github.com/fsprojects/FsHttp/\n\n\n\nFantomas\n\nhttps://github.com/fsprojects/fantomas/\n\n\n\nTelplin\n\nhttps://github.com/nojaf/telplin/\n\n\n\nFSharp.Data.Fred\n\nhttps://github.com/nhirschey/FSharp.Data.Fred/\n\n\n\nN Hirschey Teaching\n\nhttps://github.com/nhirschey/Teaching\n\n\n\nFsUnit\n\nhttps://github.com/fsprojects/FsUnit\n\n\n\nFAKE\n\nhttps://github.com/fsprojects/FAKE\n\n\n\nFSharp.Data.GraphQL\n\nhttps://github.com/fsprojects/FSharp.Data.GraphQL\n\n\n\n\n\n","headings":["Users of FSharp.Formatting"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/zero-to-hero.html","title":"Getting Started","content":"\nGetting Started\nFrom zero to hero: deploying to GitHub Pages\nThis guide is meant for a typical setup of open-source projects on GitHub.\nWe start from a repository without any documentation and aim to end up with a published website on GitHub Pages.\nInstall the local tool\nIf you don\u0027t have a dotnet tool manifest, you can create one using dotnet new tool-manifest.\nNext, we can install fsdocs-tool using dotnet tool install --local fsdocs-tool.\nIt is recommended to install this tool as a local tool because it allows us to update to newer versions of the tool at our own pace.\nCreate the docs folder\nAfter we\u0027ve installed the tool, we can run dotnet fsdocs --help and see the available commands.\nBoth build and watch will generate the documentation for a solution and an input folder.\nThe default folder for --input is the ./docs folder, relative to the current working directory.\nTypically your project will be structured like:\n/repository-root\n YourSolution.sln\n ./docs\n index.md\n other-file.md\n ./src\n ./Project1/Project1.fsproj\n ./Project2/Project2.fsproj\n\nIt is recommended to have a single solution at the root. In some editors, it is more convenient to open a solution at the root, to easily manipulate any file in root repository folder.\nWhen users clone your repository locally, they cannot be confused on how they need to open the project in their IDE.\n\u26A0\uFE0F Please avoid putting your solution in the src folder. When we open that solution, it can be more difficult to edit files in the docs folder, as we can sometimes only see the src folder.\nThat being said, let\u0027s create the docs folder and a first Markdown file named index.md.\nWhen fsdocs runs, it will transform this index.md file to index.html, which will be served at the root.\nWe can put # Hello world in the markdown file for now.\nHaving this in place, should already serve the first page when we start the watch command:\n\ndotnet fsdocs watch\n\nOpen http://localhost:8901 and you should see our first page!\n\uD83E\uDE84 You might notice that there are some images missing. You can add these in the docs folder in the right location.\nGenerating API documentation\nBy default, fsdocs will generate API documentation for the configured --projects.\nWhen this flag is not specified, fsdocs will look for solutions or projects in the working directory.\nIt will filter these found projects, the requirements are:\n\nHaving \u0026lt;OutputType\u0026gt;library\u0026lt;/OutputType\u0026gt;\nHaving a binary, so you need to build your project first before the documentation can be generated.\nNot having \u0026lt;IsTestProject\u0026gt;true\u0026lt;/IsTestProject\u0026gt;\nHaving \u0026lt;GenerateDocumentationFile\u0026gt;true\u0026lt;/GenerateDocumentationFile\u0026gt;\n\n\uD83E\uDE84 If you made some changes in order to adhere to the rules, you may want to remove the .fsdocs/cache file.\nAdding the missing properties\nAfter our initial watch run, you may have noticed that some links aren\u0027t working yet.\nLicense, Releases Notes and Source Repository can be provided by setting MSBuild properties.\nYou can either add these properties to a single .fsproj file, or more typically, add them to a Directory.Build.props file.\nThe simplest Directory.Build.props file:\n\u0026lt;Project\u0026gt;\n \u0026lt;PropertyGroup\u0026gt;\n \u0026lt;RepositoryUrl\u0026gt;https://github.com/fsprojects/FSharp.AWS.DynamoDB\u0026lt;/RepositoryUrl\u0026gt;\n \u0026lt;FsDocsLicenseLink\u0026gt;https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md\u0026lt;/FsDocsLicenseLink\u0026gt;\n \u0026lt;FsDocsReleaseNotesLink\u0026gt;https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md\u0026lt;/FsDocsReleaseNotesLink\u0026gt;\n \u0026lt;PackageProjectUrl\u0026gt;https://fsprojects.github.io/FSharp.AWS.DynamoDB\u0026lt;/PackageProjectUrl\u0026gt;\n \u0026lt;/PropertyGroup\u0026gt;\n\u0026lt;/Project\u0026gt;\n\n\uD83E\uDE84 If you don\u0027t have any release notes yet, you could consider using Ionide.KeepAChangelog.\nRunning dotnet fsdocs watch will now yield:\n root --\u0026gt; https://github.com/fsprojects/FSharp.AWS.DynamoDB/\n ...\n fsdocs-license-link --\u0026gt; https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md\n fsdocs-release-notes-link --\u0026gt; https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md\n ...\n fsdocs-repository-link --\u0026gt; https://github.com/fsprojects/FSharp.AWS.DynamoDB/\n\n\u26A0\uFE0F Again, you might need to remove .fsdocs/cache in order for changes to be picked up!\n\u0026lt;PackageProjectUrl\u0026gt; is actually a very important property when you run dotnet fsdocs build.\nbuild will generate static files for the targeted production environment. In our case, this will be GitHub Pages.\nPages will host your files from https://github.com/user/project on https://user.github.io/project/ by default.\nYou can change this by adding a custom domain so we need to be sure that all links and urls will be generated correctly during a build.\nLet\u0027s now run dotnet fsdocs build.\n\u0026lt;PackageProjectUrl\u0026gt; will replace the {{root}} substitution, which is used all over the place in the default template.\n\u26A0\uFE0F You want to ensure that the static files in the output folder (after running the build) have the correct links.\nIgnore generated files\nAlright, at this point we\u0027ve made a lot of progress. If you are using git you want to add the following to your .gitignore file.\n# FSharp.Formatting\n.fsdocs/\noutput/\ntmp/\n\nShip it!\nOnce we are satisfied with our documentation, we want to publish it to GitHub Pages.\nWe can use GitHub Actions to deploy our website.\nDeploy to Pages from GitHub Actions must be enabled in the repository settings:\n\nThe typical flow is to publish your documentation after a release or after new commits were added to the default branch.\nLet\u0027s create a very basic Action that will deploy our website after pushing to main:\nCreate a file .github/workflows/docs.yml:\nname: Docs\n\n# Trigger this Action when new code is pushed to the main branch\non:\n push:\n branches:\n - main\n\n# We need some permissions to publish to Github Pages\npermissions:\n contents: write\n pages: write\n id-token: write\n\njobs:\n build:\n runs-on: ubuntu-latest\n steps:\n # Checkout the source code\n - uses: actions/checkout@v4\n # Setup dotnet, please use a global.json to ensure the right SDK is used!\n - name: Setup .NET\n uses: actions/setup-dotnet@v3\n # Restore the local tools\n - name: Restore tools\n run: dotnet tool restore\n # Build the code for the API documentation\n - name: Build code\n run: dotnet build -c Release YourSolution.sln\n # Generate the documentation files\n - name: Generate the documentation\u0027\n run: dotnet fsdocs build --properties Configuration=Release\n # Upload the static files\n - name: Upload documentation\n uses: actions/upload-pages-artifact@v2\n with:\n path: ./output\n \n # GitHub Actions recommends deploying in a separate job.\n deploy:\n runs-on: ubuntu-latest\n needs: build\n steps:\n - name: Deploy to GitHub Pages\n id: deployment\n uses: actions/deploy-pages@v2\n\n\u26A0\uFE0F Careful yaml is indentation sensitive!\nNext steps\nMission accomplished, right? If everything went well, you should have a published website at this point!\nHere are some next steps you could consider:\nUse fsx file in your documentation\nCreate documentation using Literate Scripts. A typical flow here is that you load your locate project binary into a script and create examples using the latest code:\n#r \u0026quot;../src/Project1/bin/Debug/net6.0/Project1.dll\u0026quot;\n\nopen Project1\n\n// Actual consumption of your project!\nlet result = SomeType.SomeMethod(\u0026quot;foo\u0026quot;)\n\nWhen using the --strict flag in dotnet fsdocs build, your documentation generation will fail if your script contains errors.\nThis is useful to ensure your documentation is always in sync with your latest public API!\nAutomatically update to newer versions of fsdocs-tool\nUsing Dependabot you can easily receive new PR\u0027s with updates to your dotnet dependencies.\nCreate a .github/dependabot.yml file with:\nversion: 2\nupdates:\n # Update to newer version of GitHub Actions\n - package-ecosystem: \u0022github-actions\u0022\n directory: \u0022/\u0022\n schedule:\n interval: \u0022weekly\u0022\n\n # Update to newer NuGet dependencies\n - package-ecosystem: \u0022nuget\u0022\n directory: \u0022/\u0022\n schedule:\n interval: \u0022daily\u0022\n\nThis will automatically create a new PR when there is an update to the fsdocs tool.\n\u26A0\uFE0F P\uFE0Flease be very careful, if you have followed along, we don\u0027t have any GitHub Actions right now that run against pull requests!\nIt is recommended to have an Action that builds your documentation against any incoming changes.\nYou typically want to lint code, run unit tests and perform other useful checks as well!\nExample Action, .github/workflows/ci.yml:\nname: CI\n\non: [pull_request]\n\njobs:\n build:\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@v3\n - name: Setup .NET Core\n uses: actions/setup-dotnet@v3\n - name: Restore tools\n run: dotnet tool restore\n - name: Build\n run: dotnet build YourSolution.sln\n - name: Documentation\n run: dotnet fsdocs build\n\n\u26A0\uFE0F Also never trust any update to fsdocs blindly, always check the release notes to see if there are any breaking changes.\n","headings":["Getting Started","From zero to hero: deploying to GitHub Pages","Install the local tool","Create the docs folder","Generating API documentation","Adding the missing properties","Ignore generated files","Ship it!","Next steps","Use fsx file in your documentation","Automatically update to newer versions of fsdocs-tool"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/apidocs.html","title":"Generating API Docs","content":"\n\u0026emsp;\n\u0026emsp;\n\nAPI Documentation Generation\nThe command-line tool fsdocs can be used to generate documentation\nfor F# libraries with XML comments. The documentation is normally built using fsdocs build and developed using fsdocs watch. For\nthe former the output will be placed in output\\reference by default.\nSelected projects\nfsdocs automatically selects the projects and \u0022cracks\u0022 the project files for information\n\nProjects with GenerateDocumentationFile and without IsTestProject are selected.\nProjects must not use TargetFrameworks (only TargetFramework, singular).\n\n \u0026lt;PropertyGroup\u0026gt;\n \u0026lt;GenerateDocumentationFile\u0026gt;true\u0026lt;/GenerateDocumentationFile\u0026gt;\n \u0026lt;/PropertyGroup\u0026gt;\n\nTemplates\nThe HTML is built by instantiating a template. The template used is the first of:\n\ndocs/reference/_template.html\ndocs/_template.html\nThe default template\n\nUsually the same template can be used as for other content.\nClassic XML Doc Comments\nXML Doc Comments may use the normal F# and C# XML doc standards.\nThe tags that form the core of the XML doc specification are:\n\u0026lt;c\u0026gt;\t\u0026lt;para\u0026gt;\t\u0026lt;see\u0026gt;*\t\u0026lt;value\u0026gt;\n\u0026lt;code\u0026gt;\t\u0026lt;param\u0026gt;*\t\u0026lt;seealso\u0026gt;*\n\u0026lt;example\u0026gt;\t\u0026lt;paramref\u0026gt;\t\u0026lt;summary\u0026gt;\n\u0026lt;exception\u0026gt;*\t\u0026lt;permission\u0026gt;*\t\u0026lt;typeparam\u0026gt;*\n\u0026lt;include\u0026gt;*\t\u0026lt;remarks\u0026gt;\t\u0026lt;typeparamref\u0026gt;\n\u0026lt;list\u0026gt;\t\u0026lt;inheritdoc\u0026gt;\t\u0026lt;returns\u0026gt;\n\nIn addition, you may also use the Recommended XML doc extensions for F# documentation tooling.\n\n\u0026lt;a href = \u0022...\u0022\u0026gt; links\nArbitrary paragraph-level HTML such as \u0026lt;b\u0026gt; for bold in XML doc text\n\u0026lt;namespacedoc\u0026gt; giving documentation for the enclosing namespace\n\u0026lt;exclude/\u0026gt; to exclude from XML docs\n\n\u0026lt;category\u0026gt; to give a category for an entity or member. An optional index attribute can be specified\nto help sort the list of categories.\n\n\n\\(...\\) for inline math and $$...$$ and \\[...\\]for math environments, see \u003Ca href=\u0022http://docs.mathjax.org.\nSome\u0022\u003Ehttp://docs.mathjax.org.\nSome escaping of characters (e.g. \u0026amp;lt;, \u0026amp;gt;) may be needed to form valid XML\n\n\nAn example of an XML documentation comment, assuming the code is in namespace TheNamespace:\n/// \u0026lt;summary\u0026gt;\n/// A module\n/// \u0026lt;/summary\u0026gt;\n///\n/// \u0026lt;namespacedoc\u0026gt;\n/// \u0026lt;summary\u0026gt;A namespace to remember\u0026lt;/summary\u0026gt;\n///\n/// \u0026lt;remarks\u0026gt;More on that\u0026lt;/remarks\u0026gt;\n/// \u0026lt;/namespacedoc\u0026gt;\n///\nmodule SomeModule =\n /// \u0026lt;summary\u0026gt;\n /// Some actual comment\n /// \u0026lt;para\u0026gt;Another paragraph, see \u0026lt;see cref=\u0026quot;T:TheNamespace.SomeType\u0026quot;/\u0026gt;. \u0026lt;/para\u0026gt;\n /// \u0026lt;/summary\u0026gt;\n ///\n /// \u0026lt;param name=\u0026quot;x\u0026quot;\u0026gt;The input\u0026lt;/param\u0026gt;\n ///\n /// \u0026lt;returns\u0026gt;The output\u0026lt;/returns\u0026gt;\n ///\n /// \u0026lt;example\u0026gt;\n /// Try using\n /// \u0026lt;code\u0026gt;\n /// open TheNamespace\n /// SomeModule.a\n /// \u0026lt;/code\u0026gt;\n /// \u0026lt;/example\u0026gt;\n ///\n /// \u0026lt;category\u0026gt;Foo\u0026lt;/category\u0026gt;\n let someFunction x = 42 \u002B x\n\n/// \u0026lt;summary\u0026gt;\n/// A type, see \u0026lt;see cref=\u0026quot;T:TheNamespace.SomeModule\u0026quot;/\u0026gt; and\n/// \u0026lt;see cref=\u0026quot;M:TheNamespace.SomeModule.someFunction\u0026quot;/\u0026gt;.\n/// \u0026lt;/summary\u0026gt;\n///\ntype SomeType() =\n member x.P = 1\n\nLike types, members are referred to by xml doc sig. These must currently be precise as the F#\ncompiler doesn\u0027t elaborate these references from simpler names:\ntype Class2() =\n member this.Property = \u0026quot;more\u0026quot;\n member this.Method0() = \u0026quot;more\u0026quot;\n member this.Method1(c: string) = \u0026quot;more\u0026quot;\n member this.Method2(c: string, o: obj) = \u0026quot;more\u0026quot;\n\n/// \u0026lt;see cref=\u0026quot;P:TheNamespace.Class2.Property\u0026quot; /\u0026gt;\n/// and \u0026lt;see cref=\u0026quot;M:TheNamespace.Class2.OtherMethod0\u0026quot; /\u0026gt;\n/// and \u0026lt;see cref=\u0026quot;M:TheNamespace.Class2.Method1(System.String)\u0026quot; /\u0026gt;\n/// and \u0026lt;see cref=\u0026quot;M:TheNamespace.Class2.Method2(System.String,System.Object)\u0026quot; /\u0026gt;\nlet referringFunction1 () = \u0026quot;result\u0026quot;\n\nGeneric types are referred to by .NET compiled name, e.g.\ntype GenericClass2\u0026lt;\u0026#39;T\u0026gt;() =\n member this.Property = \u0026quot;more\u0026quot;\n\n member this.NonGenericMethod(_c: \u0026#39;T) = \u0026quot;more\u0026quot;\n\n member this.GenericMethod(_c: \u0026#39;T, _o: \u0026#39;U) = \u0026quot;more\u0026quot;\n\n/// See \u0026lt;see cref=\u0026quot;T:TheNamespace.GenericClass2\u00601\u0026quot; /\u0026gt;\n/// and \u0026lt;see cref=\u0026quot;P:TheNamespace.GenericClass2\u00601.Property\u0026quot; /\u0026gt;\n/// and \u0026lt;see cref=\u0026quot;M:TheNamespace.GenericClass2\u00601.NonGenericMethod(\u00600)\u0026quot; /\u0026gt;\n/// and \u0026lt;see cref=\u0026quot;M:TheNamespace.GenericClass2\u00601.GenericMethod\u0060\u00601(\u00600,\u0060\u00600)\u0026quot; /\u0026gt;\nlet referringFunction2 () = \u0026quot;result\u0026quot;\n\nCross-referencing with \u0026lt;seealso\u0026gt;\nUse \u0026lt;seealso cref=\u0022...\u0022/\u0026gt; within \u0026lt;summary\u0026gt; to create cross-references.\nFor example:\nmodule Forest =\n\n /// \u0026lt;summary\u0026gt;\n /// Find at most \u0026lt;c\u0026gt;limit\u0026lt;/c\u0026gt; foxes in current forest\n ///\n /// See also: \u0026lt;seealso cref=\u0026quot;M:App.Forest.findSquirrels(System.Int32)\u0026quot;/\u0026gt;\n /// \u0026lt;/summary\u0026gt;\n let findFoxes (limit : int) = []\n\n /// \u0026lt;summary\u0026gt;\n /// Find at most \u0026lt;c\u0026gt;limit\u0026lt;/c\u0026gt; squirrels in current forest\n ///\n /// See also: \u0026lt;seealso cref=\u0026quot;M:App.Forest.findFoxes(System.Int32)\u0026quot;/\u0026gt;\n /// \u0026lt;/summary\u0026gt;\n let findSquirrels (limit : int) = []\n\nYou can find the correct value for cref in the generated .xml documentation file (this will be generated alongside the assembly\u0027s .dll\u0060).\nYou can also omit the cref\u0027s arguments, and fsdocs will make an attempt to find the first member that matches.\nFor example:\n /// See also: \u0026lt;seealso cref=\u0026quot;M:App.Forest.findSquirrels\u0026quot;/\u0026gt;\n\nIf the member cannot be found, a link to the containing module/type will be used instead.\nClassic XMl Doc Comments: Excluding APIs from the docs\nIf you want to exclude modules or functions from the API docs you can use the \u0026lt;exclude/\u0026gt; tag.\nIt needs to be set on a separate triple-slashed line, and can either appear on its own or as part\nof an existing \u0026lt;summary\u0026gt; (for example, you may wish to hide existing documentation while it\u0027s in progress).\nThe \u0026lt;exclude/\u0026gt; tag can be the first or last line in these cases.\nSome examples:\n/// \u0026lt;exclude/\u0026gt;\nmodule BottleKids1 =\n let a = 42\n\n// Ordinary comment\n/// \u0026lt;exclude/\u0026gt;\nmodule BottleKids2 =\n let a = 43\n\n/// \u0026lt;exclude/\u0026gt;\n/// BottleKids3 provides improvements over BottleKids2\nmodule BottleKids3 =\n let a = 44\n\n/// BottleKids4 implements several new features over BottleKids3\n/// \u0026lt;exclude/\u0026gt;\nmodule BottleKids4 =\n let a = 45\n\n/// \u0026lt;exclude/\u0026gt;\n/// \u0026lt;summary\u0026gt;\n/// BottleKids5 is all you\u0026#39;ll ever need in terms of bottles or kids.\n/// \u0026lt;/summary\u0026gt;\nmodule BottleKids5 =\n let a = 46\n\nNote that the comments for BottleKids3 (and BottleKids4) will generate a warning. This is because\nthe \u0026lt;exclude/\u0026gt; tag will be parsed as part of the summary text, and so the documentation generator\ncan\u0027t be completely sure you meant to exclude the item, or whether it was a valid part of the documentation.\nIt will assume the exclusion was intended, but you may want to use explicit \u0026lt;summary\u0026gt; tags to remove\nthe warning.\nThe warning will be of the following format:\nWarning: detected \u0026quot;\u0026lt;exclude/\u0026gt;\u0026quot; in text of \u0026quot;\u0026lt;summary\u0026gt;\u0026quot; for \u0026quot;M:YourLib.BottleKids4\u0026quot;. Please see https://fsprojects.github.io/FSharp.Formatting/apidocs.html#Classic-XML-Doc-Comments\n\nYou will find that [omit] also works, but is considered part of the Markdown syntax and is\ndeprecated for XML Doc comments. This will also produce a warning, such as this:\nThe use of \u0060[omit]\u0060 and other commands in XML comments is deprecated, please use XML extensions, see https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md\n\nGo to Source links\n\u0027fsdocs\u0027 normally automatically adds GitHub links to each functions, values and class members for further reference.\nThis is normally done automatically based on the following settings:\n \u0026lt;RepositoryUrl\u0026gt;https://github.com/...\u0026lt;/RepositoryUrl\u0026gt;\n \u0026lt;RepositoryBranch\u0026gt;...\u0026lt;/RepositoryBranch\u0026gt;\n \u0026lt;RepositoryType\u0026gt;git\u0026lt;/RepositoryType\u0026gt;\n\nIf your source is not built from the same project where you are building documentation then\nyou may need these settings:\n \u0026lt;FsDocsSourceRepository\u0026gt;...\u0026lt;/FsDocsSourceRepository\u0026gt; -- the URL for the root of the source\n \u0026lt;FsDocsSourceFolder\u0026gt;...\u0026lt;/FsDocsSourceFolder\u0026gt; -- the root soure folder at time of build\n\nIt is assumed that sourceRepo and sourceFolder have synchronized contents.\nMarkdown Comments\nYou can use Markdown instead of XML in /// comments. If you do, you should set \u0026lt;UsesMarkdownComments\u0026gt;true\u0026lt;/UsesMarkdownComments\u0026gt; in\nyour F# project file.\n\nNote: Markdown Comments are not supported in all F# IDE tooling.\n\nAdding cross-type links to modules and types in the same assembly\nYou can automatically add cross-type links to the documentation pages of other modules and types in the same assembly.\nYou can do this in two different ways:\n\n\nAdd a markdown inline link were the link\ntitle is the name of the type you want to link.\n/// this will generate a link to [Foo.Bar] documentation\n\n\n\nAdd a Markdown inline code (using\nback-ticks) where the code is the name of the type you want to link.\n/// This will also generate a link to \u0060Foo.Bar\u0060 documentation\n\n\n\nYou can use either the full name (including namespace and module) or the simple name of a type.\nIf more than one type is found with the same name the link will not be generated.\nIf a type with the given name is not found in the same assembly the link will not be generated.\n/// Contains two types [Bar] and [Foo.Baz]\nmodule Foo =\n\n /// Bar is just an \u0060int\u0060 and belongs to module [Foo]\n type Bar = int\n\n /// Baz contains a \u0060Foo.Bar\u0060 as its \u0060id\u0060\n type Baz = { id: Bar }\n\n /// This function operates on \u0060Baz\u0060 types.\n let f (b: Baz) = b.id * 42\n\n/// Referencing [Foo3] will not generate a link as there is no type with the name \u0060Foo3\u0060\nmodule Foo3 =\n\n /// This is not the same type as \u0060Foo.Bar\u0060\n type Bar = double\n\n /// Using the simple name for [Bar] will fail to create a link because the name is duplicated in\n /// [Foo.Bar] and in [Foo3.Bar]. In this case, using the full name works.\n let f2 b = b * 50\n\nMarkdown Comments: Excluding APIs from the docs\nIf you want to exclude modules or functions from the API docs you can use the [omit] tag.\nIt needs to be set on a separate triple-slashed line, but it could be either the first or the last:\nExample as last line:\n/// Some actual comment\n/// [omit]\nmodule Bar =\n let a = 42\n\nExample as first line:\n/// [omit]\n/// Some actual comment\nmodule Bar2 =\n let a = 42\n\nBuilding library documentation programmatically\nYou can build library documentation programatically using the functionality\nin the ApiDocs type. To do this, load the assembly and open necessary namespaces:\n#r \u0026quot;FSharp.Formatting.ApiDocs.dll\u0026quot;\n\nopen FSharp.Formatting.ApiDocs\nopen System.IO\n\nFor example the ApiDocs.GenerateHtml method:\nlet file = Path.Combine(root, \u0026quot;bin/YourLibrary.dll\u0026quot;)\n\nlet input = ApiDocInput.FromFile(file)\n\nApiDocs.GenerateHtml(\n [ input ],\n output = Path.Combine(root, \u0026quot;output\u0026quot;),\n collectionName = \u0026quot;YourLibrary\u0026quot;,\n template = Path.Combine(root, \u0026quot;templates\u0026quot;, \u0026quot;template.html\u0026quot;),\n substitutions = []\n)\n\nAdding extra dependencies\nWhen building a library programmatically, you might require a reference to an additional assembly.\nYou can pass this using the otherFlags argument.\nlet projectAssembly = Path.Combine(root, \u0026quot;bin/X.dll\u0026quot;)\n\nlet projectInput = ApiDocInput.FromFile(projectAssembly)\n\nApiDocs.GenerateHtml(\n [ projectInput ],\n output = Path.Combine(root, \u0026quot;output\u0026quot;),\n collectionName = \u0026quot;Project X\u0026quot;,\n template = Path.Combine(root, \u0026quot;templates\u0026quot;, \u0026quot;template.html\u0026quot;),\n substitutions = [],\n otherFlags = [ \u0026quot;-r:/root/ProjectY/bin/Debug/net6.0/Y.dll\u0026quot; ]\n)\n\nor use libDirs to include all assemblies from an entire folder.\nTip: A combination of \u0026lt;CopyLocalLockFileAssemblies\u0026gt;true\u0026lt;/CopyLocalLockFileAssemblies\u0026gt; in the fsproj file and setting libDirs to the compilation output path leads to only one folder with all dependencies referenced.\nThis might be easier especially for large projects with many dependencies.\nApiDocs.GenerateHtml(\n [ projectInput ],\n output = Path.Combine(root, \u0026quot;output\u0026quot;),\n collectionName = \u0026quot;Project X\u0026quot;,\n template = Path.Combine(root, \u0026quot;templates\u0026quot;, \u0026quot;template.html\u0026quot;),\n substitutions = [],\n libDirs = [ \u0026quot;ProjectX/bin/Debug/netstandard2.0\u0026quot; ]\n)\n\nRebasing Links\nThe root parameter is used for the base of page and image links in the generated documentation. By default it is derived from the project\u0027s \u0026lt;PackageProjectUrl\u0026gt; property.\nIn some instances, you may wish to override the value for root (perhaps for local testing). To do this, you can use the command-line argument --parameters root \u0026lt;base\u0026gt;.\nFor example:\ndotnet fsdocs build --output public/docs --parameters root ../\n\n","headings":["API Documentation Generation","Selected projects","Templates","Classic XML Doc Comments","Cross-referencing with \u0026lt;seealso\u0026gt;","Classic XMl Doc Comments: Excluding APIs from the docs","Go to Source links","Markdown Comments","Adding cross-type links to modules and types in the same assembly","Markdown Comments: Excluding APIs from the docs","Building library documentation programmatically","Adding extra dependencies","Rebasing Links"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/sidebyside/sideextensions.html","title":"Markdown LaTeX","content":"\nExample: Using the Markdown Extensions for LaTeX\n\nTo use LaTex extension, you need add javascript\nlink to MathJax in\nyour template or inside a _head.html file.\n\u0026lt;script id=\u0022MathJax-script\u0022 async src=\u0022https://cdn.jsdelivr.net/npm/mathjax@3.0.1/es5/tex-mml-chtml.js\u0022\u0026gt;\u0026lt;/script\u0026gt;\n\nTo use inline LaTex, eclose LaTex code with $:\n\\(k_{n\u002B1} = n^2 \u002B k_n^2 - k_{n-1}\\). Alternatively,\nyou can also use $$.\nTo use block LaTex, start a new parapgraph, with\nthe first line marked as $$$ (no close $$$):\n\\[A_{m,n} =\n \\begin{pmatrix}\n a_{1,1} \u0026amp; a_{1,2} \u0026amp; \\cdots \u0026amp; a_{1,n} \\\\\n a_{2,1} \u0026amp; a_{2,2} \u0026amp; \\cdots \u0026amp; a_{2,n} \\\\\n \\vdots \u0026amp; \\vdots \u0026amp; \\ddots \u0026amp; \\vdots \\\\\n a_{m,1} \u0026amp; a_{m,2} \u0026amp; \\cdots \u0026amp; a_{m,n}\n \\end{pmatrix}\\]\nUse LaTex escape rule:\n\nEscape $ in inline mode: \\(\\$\\), \\(\\$var\\)\nOther escapes: \\(\\\u0026amp; \\% \\$ \\# \\_ \\{ \\}\\)\n\nUsing : \\(x \u0026gt; 1\\), \\(y \u0026lt; 1\\), \\(x \u0026gt;= 1\\),\n\\(y \u0026lt;= 1\\), \\(x = 1\\)\n\n\\(\u0026lt;p\u0026gt;something\u0026lt;/p\u0026gt;\\)\n\n","headings":["Example: Using the Markdown Extensions for LaTeX"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/sidebyside/sidescript.html","title":"Literate Script","content":"\nExample: Using Literate Script Content\nThis file demonstrates how to write literate F# script\nfiles (*.fsx) that can be transformed into nice HTML\nusing the literate.fsx script from the F# Formatting\npackage.\nAs you can see, a comment starting with double asterisk\nis treated as part of the document and is transformed\nusing Markdown, which means that you can use:\n\nUnordered or ordered lists\nText formatting including bold and emphasis\n\nAnd numerous other Markdown features.\nWriting F# code\nCode that is not inside comment will be formatted as\na sample snippet.\n/// The Hello World of functional languages!\nlet rec factorial x =\n if x = 0 then 1 else x * (factorial (x - 1))\n\nlet f10 = factorial 10\n\nHiding code\nIf you want to include some code in the source code,\nbut omit it from the output, you can use the hide\ncommand.\nThe value will be defined in the F# code and so you\ncan use it from other (visible) code and get correct\ntool tips:\nlet answer = hidden\n\nMoving code around\nSometimes, it is useful to first explain some code that\nhas to be located at the end of the snippet (perhaps\nbecause it uses some definitions discussed in the middle).\nThis can be done using include and define commands.\nThe following snippet gets correct tool tips, even though\nit uses laterFunction:\nlet sample = laterFunction () |\u0026gt; printfn \u0026quot;Got: %s\u0026quot;\n\nThen we can explain how laterFunction is defined:\nlet laterFunction () = \u0026quot;Not very difficult, is it?\u0026quot;\n\nThis example covers pretty much all features that are\ncurrently implemented in literate.fsx, but feel free\nto fork the project on GitHub and add more\nfeatures or report bugs!\n","headings":["Example: Using Literate Script Content","Writing F# code","Hiding code","Moving code around"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/sidebyside/sidemarkdown.html","title":"Markdown Content","content":"\nExample: Using Markdown Content\nThis file demonstrates how to write Markdown document with\nembedded F# snippets that can be transformed into nice HTML\nusing the literate.fsx script from the F# Formatting\npackage.\nIn this case, the document itself is a valid Markdown and\nyou can use standard Markdown features to format the text:\n\nHere is an example of unordered list and...\nText formatting including bold and emphasis\n\nFor more information, see the Markdown reference.\nWriting F# code\nIn standard Markdown, you can include code snippets by\nwriting a block indented by four spaces and the code\nsnippet will be turned into a \u0026lt;pre\u0026gt; element. If you do\nthe same using Literate F# tool, the code is turned into\na nicely formatted F# snippet:\n/// The Hello World of functional languages!\nlet rec factorial x = \n if x = 0 then 1 \n else x * (factorial (x - 1))\n\nlet f10 = factorial 10\n\nHiding code\nIf you want to include some code in the source code,\nbut omit it from the output, you can use the hide\ncommand. You can also use module=... to specify that\nthe snippet should be placed in a separate module\n(e.g. to avoid duplicate definitions).\nThe value will be deffined in the F# code that is\nprocessed and so you can use it from other (visible)\ncode and get correct tool tips:\nlet answer = Hidden.answer\n\nIncluding other snippets\nWhen writing literate programs as Markdown documents,\nyou can also include snippets in other languages.\nThese will not be colorized and processed as F#\ncode samples:\nConsole.WriteLine(\u0022Hello world!\u0022);\n\nThis snippet is turned into a pre element with the\nlang attribute set to csharp.\n","headings":["Example: Using Markdown Content","Writing F# code","Hiding code","Including other snippets"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/templates/leftside/styling.html","title":"Example: Styling for Right-Side Navigation Bar\n","content":"\nExample: Styling for Right-Side Navigation Bar\n\n:root {\n --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);\n --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);\n --main-menu-grid-column: 2;\n --main-grid-column: 1;\n}\n\nThe sidebar can be moved to the right by overwriting the following CSS variables in your fsdocs-theme.css file:\n:root {\n --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);\n --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);\n --main-menu-grid-column: 2;\n --main-grid-column: 1;\n}\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\nSed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?\n","headings":["Example: Styling for Right-Side Navigation Bar"],"type":"content"}]
\ No newline at end of file
diff --git a/index.md b/index.md
new file mode 100644
index 000000000..8cebe56c0
--- /dev/null
+++ b/index.md
@@ -0,0 +1,61 @@
+# F# Formatting: Documentation Tools for F# Code
+
+FSharp.Formatting is a set of libraries and tools for processing F# script files, markdown and for
+generating API documentation. F# Formatting package is used by this project and many other repositories.
+
+To use the tool, install and use the [fsdocs](commandline.html) tool in a typical F# project with
+F# project files plus markdown and script content in the `docs` directory:
+
+ dotnet tool install fsdocs-tool
+ dotnet fsdocs build
+ dotnet fsdocs watch
+
+To use the tool, explore the following topics:
+
+* [Authoring Content](content.html) - explains the content expected in the `docs` directory for the `fsdocs` tool.
+
+
+* [Using the Command line tool](commandline.html) - explains how to use the `fsdocs` tool.
+
+
+* [Generating API documentation](apidocs.html) - how to generate HTML documentation
+from "XML comments" in your .NET libraries. The tool handles comments written in
+Markdown too.
+
+
+* [Styling](styling.html) - explains some options for styling the output of `fsdocs`.
+
+
+* [Using literate programming](literate.html) - explains how to generate documentation
+for your projects or to write nicely formatted F# blog posts.
+
+
+* [Embedding F# outputs in literate programming](evaluation.html) - provides more details on literate programming and
+explains how to embed results of a literate script file in the generated output. This way,
+you can easily format the results of running your code!
+
+
+## Using FSharp.Formatting as a library
+
+F# Formatting is also [available on NuGet](https://nuget.org/packages/FSharp.Formatting) as a set of libraries.
+
+* [Markdown parser](markdown.html) - explains the F# Markdown
+processor that is available in this library with some basic examples of
+document processing.
+
+
+* [F# code formatting](codeformat.html) - more details about the F# code
+formatter and how to use it to obtain information about F# source files.
+
+
+## More information
+
+The documentation for this library is generated automatically using the tools
+built here. If you spot a typo, please submit a pull request! The source Markdown and F# script files are
+available in the [docs folder on GitHub](https://github.com/fsprojects/FSharp.Formatting/tree/master/docs).
+
+The project is hosted on [GitHub](https://github.com/fsprojects/FSharp.Formatting) where you can
+[report issues](https://github.com/fsprojects/FSharp.Formatting/issues), fork the project and submit pull requests.
+See the [License file](https://github.com/fsprojects/FSharp.Formatting/blob/master/LICENSE.md) in the GitHub repository.
+
+
diff --git a/index.tex b/index.tex
new file mode 100644
index 000000000..834aa4923
--- /dev/null
+++ b/index.tex
@@ -0,0 +1,134 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+\section*{F\# Formatting: Documentation Tools for F\# Code}
+
+
+
+FSharp.Formatting is a set of libraries and tools for processing F\# script files, markdown and for
+generating API documentation. F\# Formatting package is used by this project and many other repositories.
+
+
+To use the tool, install and use the \href{commandline.html}{fsdocs} tool in a typical F\# project with
+F\# project files plus markdown and script content in the \texttt{docs} directory:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\id{dotnet} \id{tool} \id{install} \id{fsdocs}\ops{-}\id{tool}
+\id{dotnet} \id{fsdocs} \id{build}
+\id{dotnet} \id{fsdocs} \id{watch}
+
+
+\end{lstlisting}
+
+
+
+To use the tool, explore the following topics:
+\begin{itemize}
+\item
+
+\href{content.html}{Authoring Content} - explains the content expected in the \texttt{docs} directory for the \texttt{fsdocs} tool.
+
+\item
+
+\href{commandline.html}{Using the Command line tool} - explains how to use the \texttt{fsdocs} tool.
+
+\item
+
+\href{apidocs.html}{Generating API documentation} - how to generate HTML documentation
+from "XML comments" in your .NET libraries. The tool handles comments written in
+Markdown too.
+
+\item
+
+\href{styling.html}{Styling} - explains some options for styling the output of \texttt{fsdocs}.
+
+\item
+
+\href{literate.html}{Using literate programming} - explains how to generate documentation
+for your projects or to write nicely formatted F\# blog posts.
+
+\item
+
+\href{evaluation.html}{Embedding F\# outputs in literate programming} - provides more details on literate programming and
+explains how to embed results of a literate script file in the generated output. This way,
+you can easily format the results of running your code!
+
+\end{itemize}
+
+\subsection*{Using FSharp.Formatting as a library}
+
+
+
+F\# Formatting is also \href{https://nuget.org/packages/FSharp.Formatting}{available on NuGet} as a set of libraries.
+\begin{itemize}
+\item
+
+\href{markdown.html}{Markdown parser} - explains the F\# Markdown
+processor that is available in this library with some basic examples of
+document processing.
+
+\item
+
+\href{codeformat.html}{F\# code formatting} - more details about the F\# code
+formatter and how to use it to obtain information about F\# source files.
+
+\end{itemize}
+
+\subsection*{More information}
+
+
+
+The documentation for this library is generated automatically using the tools
+built here. If you spot a typo, please submit a pull request! The source Markdown and F\# script files are
+available in the \href{https://github.com/fsprojects/FSharp.Formatting/tree/master/docs}{docs folder on GitHub}.
+
+
+The project is hosted on \href{https://github.com/fsprojects/FSharp.Formatting}{GitHub} where you can
+\href{https://github.com/fsprojects/FSharp.Formatting/issues}{report issues}, fork the project and submit pull requests.
+See the \href{https://github.com/fsprojects/FSharp.Formatting/blob/master/LICENSE.md}{License file} in the GitHub repository.
+
+
+\end{document}
\ No newline at end of file
diff --git a/literate-notebook.fsx b/literate-notebook.fsx
new file mode 100644
index 000000000..64cbf3f12
--- /dev/null
+++ b/literate-notebook.fsx
@@ -0,0 +1,53 @@
+(**
+# Literate Notebooks
+
+Content may be created using [.NET interactive](https://github.com/dotnet/interactive/tree/main) polyglot notebooks as the input file. Notebooks are processed by converting the notebook to a literate `.fsx` script and then passing the script through the script processing pipeline. Markdown notebook cells are passed through as comments surrounded by `(**` and `*)`, F# code cells are passed through as code, and non-F# code is passed through as markdown fenced code blocks between `(**` and `*)` comment markers.
+
+The `fsdocs` tool uses [dotnet-repl](https://github.com/jonsequitur/dotnet-repl) to evaluate polyglot notebooks. You need this tool to evaluate notebooks using `dotnet fsdocs [build|watch] --eval`. It can be installed into your local tool manifest using the command `dotnet tool install dotnet-repl`.
+
+F# Formatting tries to faithfully reproduce a notebook's native appearance when generating documents. Notebook cell outputs are passed through unchanged to preserve the notebook's html output. The below snippet demonstrates a notebook's html output for F# records, which differs from the output you would get with the same code inside a literate scripts.
+
+*)
+type ContactCard =
+ { Name: string
+ Phone: string
+ ZipCode: string }
+
+// Create a new record
+{ Name = "Alf"; Phone = "(555) 555-5555"; ZipCode = "90210" }
+(**
+
Content may be created using .NET interactive polyglot notebooks as the input file. Notebooks are processed by converting the notebook to a literate .fsx script and then passing the script through the script processing pipeline. Markdown notebook cells are passed through as comments surrounded by (** and *), F# code cells are passed through as code, and non-F# code is passed through as markdown fenced code blocks between (** and *) comment markers.
+
The fsdocs tool uses dotnet-repl to evaluate polyglot notebooks. You need this tool to evaluate notebooks using dotnet fsdocs [build|watch] --eval. It can be installed into your local tool manifest using the command dotnet tool install dotnet-repl.
+
F# Formatting tries to faithfully reproduce a notebook's native appearance when generating documents. Notebook cell outputs are passed through unchanged to preserve the notebook's html output. The below snippet demonstrates a notebook's html output for F# records, which differs from the output you would get with the same code inside a literate scripts.
+
typeContactCard=
+ {Name:string
+ Phone:string
+ ZipCode:string}
+
+// Create a new record
+{Name="Alf";Phone="(555) 555-5555";ZipCode="90210"}
+
+
diff --git a/literate-notebook.tex b/literate-notebook.tex
new file mode 100644
index 000000000..0c173a8fc
--- /dev/null
+++ b/literate-notebook.tex
@@ -0,0 +1,106 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Literate Notebooks}
+
+
+
+Content may be created using \href{https://github.com/dotnet/interactive/tree/main}{.NET interactive} polyglot notebooks as the input file. Notebooks are processed by converting the notebook to a literate \texttt{.fsx} script and then passing the script through the script processing pipeline. Markdown notebook cells are passed through as comments surrounded by \texttt{(**} and \texttt{*)}, F\# code cells are passed through as code, and non-F\# code is passed through as markdown fenced code blocks between \texttt{(**} and \texttt{*)} comment markers.
+
+
+The \texttt{fsdocs} tool uses \href{https://github.com/jonsequitur/dotnet-repl}{dotnet-repl} to evaluate polyglot notebooks. You need this tool to evaluate notebooks using \texttt{dotnet fsdocs [build|watch] --eval}. It can be installed into your local tool manifest using the command \texttt{dotnet tool install dotnet-repl}.
+
+
+F\# Formatting tries to faithfully reproduce a notebook's native appearance when generating documents. Notebook cell outputs are passed through unchanged to preserve the notebook's html output. The below snippet demonstrates a notebook's html output for F\# records, which differs from the output you would get with the same code inside a literate scripts.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{type} \ltyp{ContactCard} \ops{=}
+ {\{} {Name}{:} \ltyp{string}
+ {Phone}{:} \ltyp{string}
+ {ZipCode}{:} \ltyp{string} {\}}
+
+\com{// Create a new record}
+{\{} {Name} \ops{=} \str{"Alf"}{;} {Phone} \ops{=} \str{"(555) 555-5555"}{;} {ZipCode} \ops{=} \str{"90210"} {\}}
+
+\end{lstlisting}
+
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/literate.fsx b/literate.fsx
new file mode 100644
index 000000000..f617d2326
--- /dev/null
+++ b/literate.fsx
@@ -0,0 +1,271 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,1.0.0"
+(**
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=literate.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//literate.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//literate.ipynb)
+
+# Literate Scripts
+
+The following example shows most of the features that can be used in a literate
+F# script file with `.fsx` extension. Most of the features should be quite self-explanatory:
+
+ (**
+ # First-level heading
+ Some more documentation using `Markdown`.
+ *)
+
+ let helloWorld() = printfn "Hello world!"
+
+ (**
+ ## Second-level heading
+ With some more documentation
+ *)
+
+ let numbers = [ 0 .. 99 ]
+ (*** include-value: numbers ***)
+
+ List.sum numbers
+ (*** include-it ***)
+
+The F# script files is processed as follows:
+
+* A multi-line comment starting with `(**` and ending with `*)` is
+turned into text and is processed using the F# Markdown processor
+(which supports standard Markdown commands).
+
+
+* A single-line comment starting with `(***` and ending with `***)`
+is treated as a special command. The command can consist of
+`key`, `key: value` or `key=value` pairs.
+
+
+Literate Command | Description
+:--- | :---
+`(** ... *)` | Markdown
+`(*** condition: prepare ***)` | Utilise a code snippet when analyzing for tooltips or executing for outputs
+`(*** condition: ipynb ***)` | Include a code snippet when making a .ipynb notebook
+`(*** condition: tex ***)` | Include a code snippet when making a .tex output
+`(*** condition: html ***)` | Include a code snippet when making HTML output
+`(*** hide ***)` | Hide the subsequent snippet
+`(*** raw ***)` | The subsequent code is treated as raw text
+
+
+### Naming and including snippets
+
+The command `define` defines a named snippet (such as `final-sample`) and removes the command together with
+the following F# code block from the main document. The snippet can then
+be referred to in 'include'. This makes it
+possible to write documents without the ordering requirements of the
+F# language.
+
+Literate Command | Description
+:--- | :---
+`(*** define: snippet-name ***)` | Define a named snippet
+`(*** include: snippet-name ***)` | Include the code of the named snippet
+
+
+### Naming and including outputs
+
+Literate Command | Description
+:--- | :---
+`(*** define-output: output-name ***)` | Define a name for the outputs of the preceding snippet
+`(*** include-output ***)` | The console output of the preceding snippet
+`(*** include-output: output-name ***)` | The console output of the snippet (named with define-output)
+`(*** include-fsi-output ***)` | The F# Interactive output of the preceding snippet
+`(*** include-fsi-output: output-name ***)` | The F# Interactive output of the snippet (named with define-output)
+`(*** include-fsi-merged-output ***)` | The merge of console output and F# Interactive output of the preceding snippet
+`(*** include-fsi-merged-output: output-name ***)` | The merge of console output and F# Interactive output of the snippet (named with define-output)
+`(*** include-it ***)` | The formatted result of the preceding snippet
+`(*** include-it: output-name ***)` | The formatted result of the snippet (named with define-output)
+`(*** include-it-raw ***)` | The unformatted result of the preceding snippet
+`(*** include-it-raw: output-name ***)` | The unformatted result of the snippet (named with define-output)
+`(*** include-value: value-name ***)` | The formatted value, an F# identifier name
+
+
+#### Hiding code snippets
+
+The command `hide` specifies that the following F# code block (until the next comment or command) should be
+omitted from the output.
+
+#### Evaluating and formatting results
+
+The commands to evaluate and format results are explained in [evaluation](evaluation.html).
+You must build your documentation with evaluation turned on using `--eval`.
+
+#### Substitutions
+
+Substitutions are applied to content, see [content](content.html).
+
+### Literate Markdown Documents
+
+For files with `.md` extension, the entire file is a Markdown document, which may
+contain F# code snippets (but also other code snippets). As usual, snippets are
+indented with four spaces. In addition, the snippets can be annotated with special
+commands. Some of them are demonstrated in the following example:
+
+ [lang=text]
+ # First-level heading
+
+ [hide]
+ let print s = printfn "%s" s
+
+ Some more documentation using `Markdown`.
+
+ [module=Hello]
+ let helloWorld() = print "Hello world!"
+
+ ## Second-level heading
+ With some more documentation
+
+ [lang=csharp]
+ Console.WriteLine("Hello world!");
+
+When processing the document, all F# snippets are copied to a separate file that
+is type-checked using the F# compiler (to obtain colours and tool tips).
+The commands are written on the first line of the named snippet, wrapped in `[...]`:
+
+* The `hide` command specifies that the F# snippet should not be included in the
+final document. This can be used to include code that is needed to type-check
+the code, but is not visible to the reader.
+
+
+* The `module=Foo` command can be used to specify F# `module` where the snippet
+is placed. Use this command if you need multiple versions of the same snippet
+or if you need to separate code from different snippets.
+
+
+* The `lang=foo` command specifies the language of the named snippet. If the language
+is other than `fsharp`, the snippet is copied to the output as `
` HTML
+tag without any processing.
+
+
+### LaTeX in Literate Scripts and Markdown Documents
+
+Literate Scripts may contain LaTeX sections in Markdown using these forms:
+
+0 Single line latex starting with `$$`.
+
+
+1 A block delimited by `\begin{equation}...\end{equation}` or `\begin{align}...\end{align}`.
+
+
+2 An indented paragraph starting with `$$$`. This is F#-literate-specific and corresponds to
+`\begin{equation}...\end{equation}`.
+
+
+For example
+
+ [lang=text]
+ $$\frac{x}{y}$$
+
+ \begin{equation}
+ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}
+ \end{equation}
+
+Becomes
+
+\begin{equation}
+\frac{x}{y}
+\end{equation}
+
+\begin{equation}
+ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}
+\end{equation}
+
+The LaTeX will also be used in HTML and iPython notebook outputs.
+
+### Making literate scripts work for different outputs
+
+Literate scripts and markdown can by turned into LaTex, Python Notebooks and F# scripts.
+
+A header may be needed to get the code to load, a typical example is this:
+
+```text
+ (*** condition: prepare ***)
+ #nowarn "211"
+ #I "../src/FSharp.Formatting/bin/Release/netstandard2.1"
+ #r "FSharp.Formatting.Common.dll"
+ #r "FSharp.Formatting.Markdown.dll"
+ #r "FSharp.Formatting.CodeFormat.dll"
+ #r "FSharp.Formatting.Literate.dll"
+ (*** condition: fsx ***)
+#if FSX
+ #r "nuget: FSharp.Formatting,1.0.0"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,1.0.0"
+#endif // IPYNB
+```
+
+### Processing literate files programatically
+
+To process file Use the two static methods to turn single documents into HTML
+as follows using functionality from the [Literate](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html) type:
+
+*)
+open System.IO
+open FSharp.Formatting.Literate
+
+let source = __SOURCE_DIRECTORY__
+let template = Path.Combine(source, "template.html")
+
+let script = Path.Combine(source, "../docs/script.fsx")
+
+Literate.ConvertScriptFile(script, template)
+
+let doc = Path.Combine(source, "../docs/document.md")
+
+Literate.ConvertMarkdownFile(doc, template)
+(**
+The following sample also uses optional parameter `parameters` to specify additional
+keywords that will be replaced in the template file (this matches the `template-project.html`
+file which is included as a sample in the package):
+
+*)
+// Load the template & specify project information
+let projTemplate = source + "template-project.html"
+
+let projInfo =
+ [ "fsdocs-authors", "Tomas Petricek"
+ "fsdocs-source-link", "https://github.com/fsprojects/FSharp.Formatting"
+ "fsdocs-collection-name", "F# Formatting" ]
+(**
+The methods used above ([Literate.ConvertScriptFile](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertScriptFile), [Literate.ConvertMarkdownFile](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertMarkdownFile))
+produce HTML output by default, but they can be also used to produce LaTeX output. This is done
+by setting the output kind. The following
+example shows how to call the methods to generate LaTeX documents:
+
+*)
+let templateTex = Path.Combine(source, "template.tex")
+
+let scriptTex = Path.Combine(source, "../docs/script.fsx")
+
+Literate.ConvertScriptFile(scriptTex, templateTex, outputKind = OutputKind.Latex)
+
+let docTex = Path.Combine(source, "../docs/document.md")
+
+Literate.ConvertMarkdownFile(docTex, templateTex, outputKind = OutputKind.Latex)
+(**
+The methods used above (`ConvertScriptFile`, `ConvertMarkdownFile`)
+can also produce iPython Notebook output. This is done
+by setting the named parameter `format` to `OutputKind.Pynb`:
+
+*)
+// Process script file, Markdown document and a directory
+let scriptPynb = Path.Combine(source, "../docs/script.fsx")
+
+Literate.ConvertScriptFile(scriptPynb, outputKind = OutputKind.Pynb)
+
+let docPynb = Path.Combine(source, "../docs/document.md")
+
+Literate.ConvertMarkdownFile(docPynb, outputKind = OutputKind.Pynb)
+(**
+All of the three methods discussed in the previous two sections take a number of optional
+parameters that can be used to tweak how the formatting works
+
+*)
+
diff --git a/literate.html b/literate.html
new file mode 100644
index 000000000..5cb774c37
--- /dev/null
+++ b/literate.html
@@ -0,0 +1,759 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate Scripts
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The following example shows most of the features that can be used in a literate
+F# script file with .fsx extension. Most of the features should be quite self-explanatory:
+
(**
+# First-level heading
+Some more documentation using `Markdown`.
+*)
+
+lethelloWorld()=printfn"Hello world!"
+
+(**
+## Second-level heading
+With some more documentation
+*)
+
+letnumbers=[0..99]
+(*** include-value: numbers ***)
+
+List.sumnumbers
+(*** include-it ***)
+
+
The F# script files is processed as follows:
+
+
+
A multi-line comment starting with (** and ending with *) is
+turned into text and is processed using the F# Markdown processor
+(which supports standard Markdown commands).
+
+
+
A single-line comment starting with (*** and ending with ***)
+is treated as a special command. The command can consist of
+key, key: value or key=value pairs.
+
+
+
+
+
+
Literate Command
+
Description
+
+
+
+
+
(** ... *)
+
Markdown
+
+
+
(*** condition: prepare ***)
+
Utilise a code snippet when analyzing for tooltips or executing for outputs
+
+
+
(*** condition: ipynb ***)
+
Include a code snippet when making a .ipynb notebook
The command define defines a named snippet (such as final-sample) and removes the command together with
+the following F# code block from the main document. The snippet can then
+be referred to in 'include'. This makes it
+possible to write documents without the ordering requirements of the
+F# language.
For files with .md extension, the entire file is a Markdown document, which may
+contain F# code snippets (but also other code snippets). As usual, snippets are
+indented with four spaces. In addition, the snippets can be annotated with special
+commands. Some of them are demonstrated in the following example:
+
# First-level heading
+
+ [hide]
+ let print s = printfn "%s" s
+
+Some more documentation using `Markdown`.
+
+ [module=Hello]
+ let helloWorld() = print "Hello world!"
+
+## Second-level heading
+With some more documentation
+
+ [lang=csharp]
+ Console.WriteLine("Hello world!");
+
+
When processing the document, all F# snippets are copied to a separate file that
+is type-checked using the F# compiler (to obtain colours and tool tips).
+The commands are written on the first line of the named snippet, wrapped in [...]:
+
+
+
The hide command specifies that the F# snippet should not be included in the
+final document. This can be used to include code that is needed to type-check
+the code, but is not visible to the reader.
+
+
+
The module=Foo command can be used to specify F# module where the snippet
+is placed. Use this command if you need multiple versions of the same snippet
+or if you need to separate code from different snippets.
+
+
+
The lang=foo command specifies the language of the named snippet. If the language
+is other than fsharp, the snippet is copied to the output as <pre> HTML
+tag without any processing.
The following sample also uses optional parameter parameters to specify additional
+keywords that will be replaced in the template file (this matches the template-project.html
+file which is included as a sample in the package):
+
// Load the template & specify project information
+letprojTemplate=source+"template-project.html"
+
+letprojInfo=
+ ["fsdocs-authors","Tomas Petricek"
+ "fsdocs-source-link","https://github.com/fsprojects/FSharp.Formatting"
+ "fsdocs-collection-name","F# Formatting"]
+
+
The methods used above (Literate.ConvertScriptFile, Literate.ConvertMarkdownFile)
+produce HTML output by default, but they can be also used to produce LaTeX output. This is done
+by setting the output kind. The following
+example shows how to call the methods to generate LaTeX documents:
The methods used above (ConvertScriptFile, ConvertMarkdownFile)
+can also produce iPython Notebook output. This is done
+by setting the named parameter format to OutputKind.Pynb:
+
// Process script file, Markdown document and a directory
+letscriptPynb=Path.Combine(source,"../docs/script.fsx")
+
+Literate.ConvertScriptFile(scriptPynb,outputKind=OutputKind.Pynb)
+
+letdocPynb=Path.Combine(source,"../docs/document.md")
+
+Literate.ConvertMarkdownFile(docPynb,outputKind=OutputKind.Pynb)
+
+
All of the three methods discussed in the previous two sections take a number of optional
+parameters that can be used to tweak how the formatting works
+
+
val helloWorld: unit -> unit
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
val numbers: int list
+
Multiple items module List
+
+from Microsoft.FSharp.Collections
-------------------- type List<'T> =
+ | op_Nil
+ | op_ColonColon of Head: 'T * Tail: 'T list
+ interface IReadOnlyList<'T>
+ interface IReadOnlyCollection<'T>
+ interface IEnumerable
+ interface IEnumerable<'T>
+ member GetReverseIndex: rank: int * offset: int -> int
+ member GetSlice: startIndex: int option * endIndex: int option -> 'T list
+ static member Cons: head: 'T * tail: 'T list -> 'T list
+ member Head: 'T
+ member IsEmpty: bool
+ member Item: index: int -> 'T with get
+ ...
+
val sum: list: 'T list -> 'T (requires member (+) and member Zero)
+
namespace System
+
namespace System.IO
+
Multiple items namespace FSharp
-------------------- namespace Microsoft.FSharp
+
namespace FSharp.Formatting
+
namespace FSharp.Formatting.Literate
+
val source: string
+
val template: string
+
type Path =
+ static member ChangeExtension: path: string * extension: string -> string
+ static member Combine: path1: string * path2: string -> string + 3 overloads
+ static member EndsInDirectorySeparator: path: ReadOnlySpan<char> -> bool + 1 overload
+ static member Exists: path: string -> bool
+ static member GetDirectoryName: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetExtension: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetFileName: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetFileNameWithoutExtension: path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
+ static member GetFullPath: path: string -> string + 1 overload
+ static member GetInvalidFileNameChars: unit -> char array
+ ... <summary>Performs operations on <see cref="T:System.String" /> instances that contain file or directory path information. These operations are performed in a cross-platform manner.</summary>
[<Struct>]
+type OutputKind =
+ | Html
+ | Latex
+ | Pynb
+ | Fsx
+ | Markdown
+ member Extension: string <summary>
+ Defines the possible output types from literate script (HTML, Latex, Pynb)
+</summary>
+
union case OutputKind.Latex: OutputKind <summary>
+ Requests LaTeX output
+</summary>
+
val docTex: string
+
val scriptPynb: string
+
union case OutputKind.Pynb: OutputKind <summary>
+ Requests Notebook output
+</summary>
+
val docPynb: string
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/literate.ipynb b/literate.ipynb
new file mode 100644
index 000000000..97e0f805d
--- /dev/null
+++ b/literate.ipynb
@@ -0,0 +1,413 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "#r \"nuget: FSharp.Formatting,1.0.0\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=literate.ipynb)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//literate.fsx)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//literate.ipynb)\n",
+ "\n",
+ "# Literate Scripts\n",
+ "\n",
+ "The following example shows most of the features that can be used in a literate\n",
+ "F# script file with `.fsx` extension. Most of the features should be quite self-explanatory:\n",
+ "\n",
+ " (**\n",
+ " # First-level heading\n",
+ " Some more documentation using `Markdown`.\n",
+ " *)\n",
+ "\n",
+ " let helloWorld() = printfn \"Hello world!\"\n",
+ "\n",
+ " (**\n",
+ " ## Second-level heading\n",
+ " With some more documentation\n",
+ " *)\n",
+ "\n",
+ " let numbers = [ 0 .. 99 ]\n",
+ " (*** include-value: numbers ***)\n",
+ "\n",
+ " List.sum numbers\n",
+ " (*** include-it ***)\n",
+ "\n",
+ "The F# script files is processed as follows:\n",
+ "\n",
+ "* A multi-line comment starting with `(**` and ending with `*)` is\n",
+ "turned into text and is processed using the F# Markdown processor\n",
+ "(which supports standard Markdown commands).\n",
+ " \n",
+ "\n",
+ "* A single-line comment starting with `(***` and ending with `***)`\n",
+ "is treated as a special command. The command can consist of\n",
+ "`key`, `key: value` or `key=value` pairs.\n",
+ " \n",
+ "\n",
+ "Literate Command | Description\n",
+ ":--- | :---\n",
+ "`(** ... *)` | Markdown\n",
+ "`(*** condition: prepare ***)` | Utilise a code snippet when analyzing for tooltips or executing for outputs\n",
+ "`(*** condition: ipynb ***)` | Include a code snippet when making a .ipynb notebook\n",
+ "`(*** condition: tex ***)` | Include a code snippet when making a .tex output\n",
+ "`(*** condition: html ***)` | Include a code snippet when making HTML output\n",
+ "`(*** hide ***)` | Hide the subsequent snippet\n",
+ "`(*** raw ***)` | The subsequent code is treated as raw text\n",
+ "\n",
+ "\n",
+ "### Naming and including snippets\n",
+ "\n",
+ "The command `define` defines a named snippet (such as `final-sample`) and removes the command together with\n",
+ "the following F# code block from the main document. The snippet can then\n",
+ "be referred to in \u0027include\u0027. This makes it\n",
+ "possible to write documents without the ordering requirements of the\n",
+ "F# language.\n",
+ "\n",
+ "Literate Command | Description\n",
+ ":--- | :---\n",
+ "`(*** define: snippet-name ***)` | Define a named snippet\n",
+ "`(*** include: snippet-name ***)` | Include the code of the named snippet\n",
+ "\n",
+ "\n",
+ "### Naming and including outputs\n",
+ "\n",
+ "Literate Command | Description\n",
+ ":--- | :---\n",
+ "`(*** define-output: output-name ***)` | Define a name for the outputs of the preceding snippet\n",
+ "`(*** include-output ***)` | The console output of the preceding snippet\n",
+ "`(*** include-output: output-name ***)` | The console output of the snippet (named with define-output)\n",
+ "`(*** include-fsi-output ***)` | The F# Interactive output of the preceding snippet\n",
+ "`(*** include-fsi-output: output-name ***)` | The F# Interactive output of the snippet (named with define-output)\n",
+ "`(*** include-fsi-merged-output ***)` | The merge of console output and F# Interactive output of the preceding snippet\n",
+ "`(*** include-fsi-merged-output: output-name ***)` | The merge of console output and F# Interactive output of the snippet (named with define-output)\n",
+ "`(*** include-it ***)` | The formatted result of the preceding snippet\n",
+ "`(*** include-it: output-name ***)` | The formatted result of the snippet (named with define-output)\n",
+ "`(*** include-it-raw ***)` | The unformatted result of the preceding snippet\n",
+ "`(*** include-it-raw: output-name ***)` | The unformatted result of the snippet (named with define-output)\n",
+ "`(*** include-value: value-name ***)` | The formatted value, an F# identifier name\n",
+ "\n",
+ "\n",
+ "#### Hiding code snippets\n",
+ "\n",
+ "The command `hide` specifies that the following F# code block (until the next comment or command) should be\n",
+ "omitted from the output.\n",
+ "\n",
+ "#### Evaluating and formatting results\n",
+ "\n",
+ "The commands to evaluate and format results are explained in [evaluation](evaluation.html).\n",
+ "You must build your documentation with evaluation turned on using `--eval`.\n",
+ "\n",
+ "#### Substitutions\n",
+ "\n",
+ "Substitutions are applied to content, see [content](content.html).\n",
+ "\n",
+ "### Literate Markdown Documents\n",
+ "\n",
+ "For files with `.md` extension, the entire file is a Markdown document, which may\n",
+ "contain F# code snippets (but also other code snippets). As usual, snippets are\n",
+ "indented with four spaces. In addition, the snippets can be annotated with special\n",
+ "commands. Some of them are demonstrated in the following example:\n",
+ "\n",
+ " [lang=text]\n",
+ " # First-level heading\n",
+ "\n",
+ " [hide]\n",
+ " let print s = printfn \"%s\" s\n",
+ "\n",
+ " Some more documentation using `Markdown`.\n",
+ "\n",
+ " [module=Hello]\n",
+ " let helloWorld() = print \"Hello world!\"\n",
+ "\n",
+ " ## Second-level heading\n",
+ " With some more documentation\n",
+ "\n",
+ " [lang=csharp]\n",
+ " Console.WriteLine(\"Hello world!\");\n",
+ "\n",
+ "When processing the document, all F# snippets are copied to a separate file that\n",
+ "is type-checked using the F# compiler (to obtain colours and tool tips).\n",
+ "The commands are written on the first line of the named snippet, wrapped in `[...]`:\n",
+ "\n",
+ "* The `hide` command specifies that the F# snippet should not be included in the\n",
+ "final document. This can be used to include code that is needed to type-check\n",
+ "the code, but is not visible to the reader.\n",
+ " \n",
+ "\n",
+ "* The `module=Foo` command can be used to specify F# `module` where the snippet\n",
+ "is placed. Use this command if you need multiple versions of the same snippet\n",
+ "or if you need to separate code from different snippets.\n",
+ " \n",
+ "\n",
+ "* The `lang=foo` command specifies the language of the named snippet. If the language\n",
+ "is other than `fsharp`, the snippet is copied to the output as `\u003cpre\u003e` HTML\n",
+ "tag without any processing.\n",
+ " \n",
+ "\n",
+ "### LaTeX in Literate Scripts and Markdown Documents\n",
+ "\n",
+ "Literate Scripts may contain LaTeX sections in Markdown using these forms:\n",
+ "\n",
+ "0 Single line latex starting with `$$`.\n",
+ " \n",
+ "\n",
+ "1 A block delimited by `\\begin{equation}...\\end{equation}` or `\\begin{align}...\\end{align}`.\n",
+ " \n",
+ "\n",
+ "2 An indented paragraph starting with `$$$`. This is F#-literate-specific and corresponds to\n",
+ "`\\begin{equation}...\\end{equation}`.\n",
+ " \n",
+ "\n",
+ "For example\n",
+ "\n",
+ " [lang=text]\n",
+ " $$\\frac{x}{y}$$\n",
+ "\n",
+ " \\begin{equation}\n",
+ " \\frac{d}{dx} \\left. \\left( x \\left( \\left. \\frac{d}{dy} x y \\; \\right|_{y=3} \\right) \\right) \\right|_{x=2}\n",
+ " \\end{equation}\n",
+ "\n",
+ "Becomes\n",
+ "\n",
+ "\\begin{equation}\n",
+ "\\frac{x}{y}\n",
+ "\\end{equation}\n",
+ "\n",
+ "\\begin{equation}\n",
+ " \\frac{d}{dx} \\left. \\left( x \\left( \\left. \\frac{d}{dy} x y \\; \\right|_{y=3} \\right) \\right) \\right|_{x=2}\n",
+ "\\end{equation}\n",
+ "\n",
+ "The LaTeX will also be used in HTML and iPython notebook outputs.\n",
+ "\n",
+ "### Making literate scripts work for different outputs\n",
+ "\n",
+ "Literate scripts and markdown can by turned into LaTex, Python Notebooks and F# scripts.\n",
+ "\n",
+ "A header may be needed to get the code to load, a typical example is this:\n",
+ "\n",
+ "```text\n",
+ " (*** condition: prepare ***)\n",
+ " #nowarn \"211\"\n",
+ " #I \"../src/FSharp.Formatting/bin/Release/netstandard2.1\"\n",
+ " #r \"FSharp.Formatting.Common.dll\"\n",
+ " #r \"FSharp.Formatting.Markdown.dll\"\n",
+ " #r \"FSharp.Formatting.CodeFormat.dll\"\n",
+ " #r \"FSharp.Formatting.Literate.dll\"\n",
+ " (*** condition: fsx ***)\n",
+ "#if FSX\n",
+ " #r \"nuget: FSharp.Formatting,1.0.0\"\n",
+ "#endif // FSX\n",
+ " (*** condition: ipynb ***)\n",
+ "#if IPYNB\n",
+ " #r \"nuget: FSharp.Formatting,1.0.0\"\n",
+ "#endif // IPYNB\n",
+ "```\n",
+ "\n",
+ "### Processing literate files programatically\n",
+ "\n",
+ "To process file Use the two static methods to turn single documents into HTML\n",
+ "as follows using functionality from the [Literate](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html) type:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "open System.IO\n",
+ "open FSharp.Formatting.Literate\n",
+ "\n",
+ "let source = __SOURCE_DIRECTORY__\n",
+ "let template = Path.Combine(source, \"template.html\")\n",
+ "\n",
+ "let script = Path.Combine(source, \"../docs/script.fsx\")\n",
+ "\n",
+ "Literate.ConvertScriptFile(script, template)\n",
+ "\n",
+ "let doc = Path.Combine(source, \"../docs/document.md\")\n",
+ "\n",
+ "Literate.ConvertMarkdownFile(doc, template)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The following sample also uses optional parameter `parameters` to specify additional\n",
+ "keywords that will be replaced in the template file (this matches the `template-project.html`\n",
+ "file which is included as a sample in the package):\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "// Load the template \u0026 specify project information\n",
+ "let projTemplate = source + \"template-project.html\"\n",
+ "\n",
+ "let projInfo =\n",
+ " [ \"fsdocs-authors\", \"Tomas Petricek\"\n",
+ " \"fsdocs-source-link\", \"https://github.com/fsprojects/FSharp.Formatting\"\n",
+ " \"fsdocs-collection-name\", \"F# Formatting\" ]\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The methods used above ([Literate.ConvertScriptFile](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertScriptFile), [Literate.ConvertMarkdownFile](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertMarkdownFile))\n",
+ "produce HTML output by default, but they can be also used to produce LaTeX output. This is done\n",
+ "by setting the output kind. The following\n",
+ "example shows how to call the methods to generate LaTeX documents:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let templateTex = Path.Combine(source, \"template.tex\")\n",
+ "\n",
+ "let scriptTex = Path.Combine(source, \"../docs/script.fsx\")\n",
+ "\n",
+ "Literate.ConvertScriptFile(scriptTex, templateTex, outputKind = OutputKind.Latex)\n",
+ "\n",
+ "let docTex = Path.Combine(source, \"../docs/document.md\")\n",
+ "\n",
+ "Literate.ConvertMarkdownFile(docTex, templateTex, outputKind = OutputKind.Latex)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The methods used above (`ConvertScriptFile`, `ConvertMarkdownFile`)\n",
+ "can also produce iPython Notebook output. This is done\n",
+ "by setting the named parameter `format` to `OutputKind.Pynb`:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "// Process script file, Markdown document and a directory\n",
+ "let scriptPynb = Path.Combine(source, \"../docs/script.fsx\")\n",
+ "\n",
+ "Literate.ConvertScriptFile(scriptPynb, outputKind = OutputKind.Pynb)\n",
+ "\n",
+ "let docPynb = Path.Combine(source, \"../docs/document.md\")\n",
+ "\n",
+ "Literate.ConvertMarkdownFile(docPynb, outputKind = OutputKind.Pynb)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "All of the three methods discussed in the previous two sections take a number of optional\n",
+ "parameters that can be used to tweak how the formatting works\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/literate.md b/literate.md
new file mode 100644
index 000000000..e594025f3
--- /dev/null
+++ b/literate.md
@@ -0,0 +1,268 @@
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=literate.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//literate.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//literate.ipynb)
+
+# Literate Scripts
+
+The following example shows most of the features that can be used in a literate
+F# script file with `.fsx` extension. Most of the features should be quite self-explanatory:
+
+```fsharp
+(**
+# First-level heading
+Some more documentation using `Markdown`.
+*)
+
+let helloWorld() = printfn "Hello world!"
+
+(**
+## Second-level heading
+With some more documentation
+*)
+
+let numbers = [ 0 .. 99 ]
+(*** include-value: numbers ***)
+
+List.sum numbers
+(*** include-it ***)
+
+```
+
+The F# script files is processed as follows:
+
+* A multi-line comment starting with `(**` and ending with `*)` is
+turned into text and is processed using the F# Markdown processor
+(which supports standard Markdown commands).
+
+
+* A single-line comment starting with `(***` and ending with `***)`
+is treated as a special command. The command can consist of
+`key`, `key: value` or `key=value` pairs.
+
+
+Literate Command | Description
+:--- | :---
+`(** ... *)` | Markdown
+`(*** condition: prepare ***)` | Utilise a code snippet when analyzing for tooltips or executing for outputs
+`(*** condition: ipynb ***)` | Include a code snippet when making a .ipynb notebook
+`(*** condition: tex ***)` | Include a code snippet when making a .tex output
+`(*** condition: html ***)` | Include a code snippet when making HTML output
+`(*** hide ***)` | Hide the subsequent snippet
+`(*** raw ***)` | The subsequent code is treated as raw text
+
+
+### Naming and including snippets
+
+The command `define` defines a named snippet (such as `final-sample`) and removes the command together with
+the following F# code block from the main document. The snippet can then
+be referred to in 'include'. This makes it
+possible to write documents without the ordering requirements of the
+F# language.
+
+Literate Command | Description
+:--- | :---
+`(*** define: snippet-name ***)` | Define a named snippet
+`(*** include: snippet-name ***)` | Include the code of the named snippet
+
+
+### Naming and including outputs
+
+Literate Command | Description
+:--- | :---
+`(*** define-output: output-name ***)` | Define a name for the outputs of the preceding snippet
+`(*** include-output ***)` | The console output of the preceding snippet
+`(*** include-output: output-name ***)` | The console output of the snippet (named with define-output)
+`(*** include-fsi-output ***)` | The F# Interactive output of the preceding snippet
+`(*** include-fsi-output: output-name ***)` | The F# Interactive output of the snippet (named with define-output)
+`(*** include-fsi-merged-output ***)` | The merge of console output and F# Interactive output of the preceding snippet
+`(*** include-fsi-merged-output: output-name ***)` | The merge of console output and F# Interactive output of the snippet (named with define-output)
+`(*** include-it ***)` | The formatted result of the preceding snippet
+`(*** include-it: output-name ***)` | The formatted result of the snippet (named with define-output)
+`(*** include-it-raw ***)` | The unformatted result of the preceding snippet
+`(*** include-it-raw: output-name ***)` | The unformatted result of the snippet (named with define-output)
+`(*** include-value: value-name ***)` | The formatted value, an F# identifier name
+
+
+#### Hiding code snippets
+
+The command `hide` specifies that the following F# code block (until the next comment or command) should be
+omitted from the output.
+
+#### Evaluating and formatting results
+
+The commands to evaluate and format results are explained in [evaluation](evaluation.html).
+You must build your documentation with evaluation turned on using `--eval`.
+
+#### Substitutions
+
+Substitutions are applied to content, see [content](content.html).
+
+### Literate Markdown Documents
+
+For files with `.md` extension, the entire file is a Markdown document, which may
+contain F# code snippets (but also other code snippets). As usual, snippets are
+indented with four spaces. In addition, the snippets can be annotated with special
+commands. Some of them are demonstrated in the following example:
+
+# First-level heading
+
+ [hide]
+ let print s = printfn "%s" s
+
+Some more documentation using `Markdown`.
+
+ [module=Hello]
+ let helloWorld() = print "Hello world!"
+
+## Second-level heading
+With some more documentation
+
+ [lang=csharp]
+ Console.WriteLine("Hello world!");
+
+When processing the document, all F# snippets are copied to a separate file that
+is type-checked using the F# compiler (to obtain colours and tool tips).
+The commands are written on the first line of the named snippet, wrapped in `[...]`:
+
+* The `hide` command specifies that the F# snippet should not be included in the
+final document. This can be used to include code that is needed to type-check
+the code, but is not visible to the reader.
+
+
+* The `module=Foo` command can be used to specify F# `module` where the snippet
+is placed. Use this command if you need multiple versions of the same snippet
+or if you need to separate code from different snippets.
+
+
+* The `lang=foo` command specifies the language of the named snippet. If the language
+is other than `fsharp`, the snippet is copied to the output as `
` HTML
+tag without any processing.
+
+
+### LaTeX in Literate Scripts and Markdown Documents
+
+Literate Scripts may contain LaTeX sections in Markdown using these forms:
+
+0 Single line latex starting with `$$`.
+
+
+1 A block delimited by `\begin{equation}...\end{equation}` or `\begin{align}...\end{align}`.
+
+
+2 An indented paragraph starting with `$$$`. This is F#-literate-specific and corresponds to
+`\begin{equation}...\end{equation}`.
+
+
+For example
+
+$$\frac{x}{y}$$
+
+\begin{equation}
+ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}
+\end{equation}
+
+Becomes
+
+\begin{equation}
+\frac{x}{y}
+\end{equation}
+
+\begin{equation}
+ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}
+\end{equation}
+
+The LaTeX will also be used in HTML and iPython notebook outputs.
+
+### Making literate scripts work for different outputs
+
+Literate scripts and markdown can by turned into LaTex, Python Notebooks and F# scripts.
+
+A header may be needed to get the code to load, a typical example is this:
+
+ (*** condition: prepare ***)
+ #nowarn "211"
+ #I "../src/FSharp.Formatting/bin/Release/netstandard2.1"
+ #r "FSharp.Formatting.Common.dll"
+ #r "FSharp.Formatting.Markdown.dll"
+ #r "FSharp.Formatting.CodeFormat.dll"
+ #r "FSharp.Formatting.Literate.dll"
+ (*** condition: fsx ***)
+#if FSX
+ #r "nuget: FSharp.Formatting,1.0.0"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,1.0.0"
+#endif // IPYNB
+
+### Processing literate files programatically
+
+To process file Use the two static methods to turn single documents into HTML
+as follows using functionality from the [Literate](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html) type:
+
+```fsharp
+open System.IO
+open FSharp.Formatting.Literate
+
+let source = __SOURCE_DIRECTORY__
+let template = Path.Combine(source, "template.html")
+
+let script = Path.Combine(source, "../docs/script.fsx")
+
+Literate.ConvertScriptFile(script, template)
+
+let doc = Path.Combine(source, "../docs/document.md")
+
+Literate.ConvertMarkdownFile(doc, template)
+```
+
+The following sample also uses optional parameter `parameters` to specify additional
+keywords that will be replaced in the template file (this matches the `template-project.html`
+file which is included as a sample in the package):
+
+```fsharp
+// Load the template & specify project information
+let projTemplate = source + "template-project.html"
+
+let projInfo =
+ [ "fsdocs-authors", "Tomas Petricek"
+ "fsdocs-source-link", "https://github.com/fsprojects/FSharp.Formatting"
+ "fsdocs-collection-name", "F# Formatting" ]
+```
+
+The methods used above ([Literate.ConvertScriptFile](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertScriptFile), [Literate.ConvertMarkdownFile](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertMarkdownFile))
+produce HTML output by default, but they can be also used to produce LaTeX output. This is done
+by setting the output kind. The following
+example shows how to call the methods to generate LaTeX documents:
+
+```fsharp
+let templateTex = Path.Combine(source, "template.tex")
+
+let scriptTex = Path.Combine(source, "../docs/script.fsx")
+
+Literate.ConvertScriptFile(scriptTex, templateTex, outputKind = OutputKind.Latex)
+
+let docTex = Path.Combine(source, "../docs/document.md")
+
+Literate.ConvertMarkdownFile(docTex, templateTex, outputKind = OutputKind.Latex)
+```
+
+The methods used above (`ConvertScriptFile`, `ConvertMarkdownFile`)
+can also produce iPython Notebook output. This is done
+by setting the named parameter `format` to `OutputKind.Pynb`:
+
+```fsharp
+// Process script file, Markdown document and a directory
+let scriptPynb = Path.Combine(source, "../docs/script.fsx")
+
+Literate.ConvertScriptFile(scriptPynb, outputKind = OutputKind.Pynb)
+
+let docPynb = Path.Combine(source, "../docs/document.md")
+
+Literate.ConvertMarkdownFile(docPynb, outputKind = OutputKind.Pynb)
+```
+
+All of the three methods discussed in the previous two sections take a number of optional
+parameters that can be used to tweak how the formatting works
+
+
diff --git a/literate.tex b/literate.tex
new file mode 100644
index 000000000..b886dcdab
--- /dev/null
+++ b/literate.tex
@@ -0,0 +1,392 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+
+
+\href{https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=literate.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-binder.svg}
+\caption{Binder}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//literate.fsx}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-script.svg}
+\caption{Script}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//literate.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-notebook.svg}
+\caption{Notebook}
+\end{figure}
+}
+\section*{Literate Scripts}
+
+
+
+The following example shows most of the features that can be used in a literate
+F\# script file with \texttt{.fsx} extension. Most of the features should be quite self-explanatory:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{(**}
+\com{\# First-level heading}
+\com{Some more documentation using `Markdown`.}
+\com{*)}
+
+\kwd{let} \lfun{helloWorld}{(}{)} \ops{=} \lfun{printfn} \str{"Hello world!"}
+
+\com{(**}
+\com{\#\# Second-level heading}
+\com{With some more documentation}
+\com{*)}
+
+\kwd{let} \id{numbers} \ops{=} {[} \num{0} \ops{..} \num{99} {]}
+\com{(*** include-value: numbers ***)}
+
+\ltyp{List}{.}\id{sum} \id{numbers}
+\com{(*** include-it ***)}
+
+
+\end{lstlisting}
+
+
+
+The F\# script files is processed as follows:
+\begin{itemize}
+\item
+
+A multi-line comment starting with \texttt{(**} and ending with \texttt{*)} is
+turned into text and is processed using the F\# Markdown processor
+(which supports standard Markdown commands).
+
+\item
+
+A single-line comment starting with \texttt{(***} and ending with \texttt{***)}
+is treated as a special command. The command can consist of
+\texttt{key}, \texttt{key: value} or \texttt{key=value} pairs.
+
+\end{itemize}
+
+\begin{tabular}{|l|l|}\hline
+\textbf{Literate Command} & \textbf{Description}\\ \hline\hline
+\texttt{(** ... *)} & Markdown\\ \hline
+\texttt{(*** condition: prepare ***)} & Utilise a code snippet when analyzing for tooltips or executing for outputs\\ \hline
+\texttt{(*** condition: ipynb ***)} & Include a code snippet when making a .ipynb notebook\\ \hline
+\texttt{(*** condition: tex ***)} & Include a code snippet when making a .tex output\\ \hline
+\texttt{(*** condition: html ***)} & Include a code snippet when making HTML output\\ \hline
+\texttt{(*** hide ***)} & Hide the subsequent snippet\\ \hline
+\texttt{(*** raw ***)} & The subsequent code is treated as raw text\\ \hline
+\end{tabular}
+
+\subsubsection*{Naming and including snippets}
+
+
+
+The command \texttt{define} defines a named snippet (such as \texttt{final-sample}) and removes the command together with
+the following F\# code block from the main document. The snippet can then
+be referred to in 'include'. This makes it
+possible to write documents without the ordering requirements of the
+F\# language.
+\begin{tabular}{|l|l|}\hline
+\textbf{Literate Command} & \textbf{Description}\\ \hline\hline
+\texttt{(*** define: snippet-name ***)} & Define a named snippet\\ \hline
+\texttt{(*** include: snippet-name ***)} & Include the code of the named snippet\\ \hline
+\end{tabular}
+
+\subsubsection*{Naming and including outputs}
+
+\begin{tabular}{|l|l|}\hline
+\textbf{Literate Command} & \textbf{Description}\\ \hline\hline
+\texttt{(*** define-output: output-name ***)} & Define a name for the outputs of the preceding snippet\\ \hline
+\texttt{(*** include-output ***)} & The console output of the preceding snippet\\ \hline
+\texttt{(*** include-output: output-name ***)} & The console output of the snippet (named with define-output)\\ \hline
+\texttt{(*** include-fsi-output ***)} & The F\# Interactive output of the preceding snippet\\ \hline
+\texttt{(*** include-fsi-output: output-name ***)} & The F\# Interactive output of the snippet (named with define-output)\\ \hline
+\texttt{(*** include-fsi-merged-output ***)} & The merge of console output and F\# Interactive output of the preceding snippet\\ \hline
+\texttt{(*** include-fsi-merged-output: output-name ***)} & The merge of console output and F\# Interactive output of the snippet (named with define-output)\\ \hline
+\texttt{(*** include-it ***)} & The formatted result of the preceding snippet\\ \hline
+\texttt{(*** include-it: output-name ***)} & The formatted result of the snippet (named with define-output)\\ \hline
+\texttt{(*** include-it-raw ***)} & The unformatted result of the preceding snippet\\ \hline
+\texttt{(*** include-it-raw: output-name ***)} & The unformatted result of the snippet (named with define-output)\\ \hline
+\texttt{(*** include-value: value-name ***)} & The formatted value, an F\# identifier name\\ \hline
+\end{tabular}
+
+\paragraph{Hiding code snippets}
+
+
+
+The command \texttt{hide} specifies that the following F\# code block (until the next comment or command) should be
+omitted from the output.
+\paragraph{Evaluating and formatting results}
+
+
+
+The commands to evaluate and format results are explained in \href{evaluation.html}{evaluation}.
+You must build your documentation with evaluation turned on using \texttt{--eval}.
+\paragraph{Substitutions}
+
+
+
+Substitutions are applied to content, see \href{content.html}{content}.
+\subsubsection*{Literate Markdown Documents}
+
+
+
+For files with \texttt{.md} extension, the entire file is a Markdown document, which may
+contain F\# code snippets (but also other code snippets). As usual, snippets are
+indented with four spaces. In addition, the snippets can be annotated with special
+commands. Some of them are demonstrated in the following example:
+\begin{lstlisting}
+# First-level heading
+
+ [hide]
+ let print s = printfn "%s" s
+
+Some more documentation using `Markdown`.
+
+ [module=Hello]
+ let helloWorld() = print "Hello world!"
+
+## Second-level heading
+With some more documentation
+
+ [lang=csharp]
+ Console.WriteLine("Hello world!");
+
+\end{lstlisting}
+
+
+When processing the document, all F\# snippets are copied to a separate file that
+is type-checked using the F\# compiler (to obtain colours and tool tips).
+The commands are written on the first line of the named snippet, wrapped in \texttt{[...]}:
+\begin{itemize}
+\item
+
+The \texttt{hide} command specifies that the F\# snippet should not be included in the
+final document. This can be used to include code that is needed to type-check
+the code, but is not visible to the reader.
+
+\item
+
+The \texttt{module=Foo} command can be used to specify F\# \texttt{module} where the snippet
+is placed. Use this command if you need multiple versions of the same snippet
+or if you need to separate code from different snippets.
+
+\item
+
+The \texttt{lang=foo} command specifies the language of the named snippet. If the language
+is other than \texttt{fsharp}, the snippet is copied to the output as \texttt{
} HTML
+tag without any processing.
+
+\end{itemize}
+
+\subsubsection*{LaTeX in Literate Scripts and Markdown Documents}
+
+
+
+Literate Scripts may contain LaTeX sections in Markdown using these forms:
+\begin{enumerate}
+\item
+
+Single line latex starting with \texttt{\$\$}.
+
+\item
+
+A block delimited by \texttt{{\textbackslash}begin\{equation\}...{\textbackslash}end\{equation\}} or \texttt{{\textbackslash}begin\{align\}...{\textbackslash}end\{align\}}.
+
+\item
+
+An indented paragraph starting with \texttt{\$\$\$}. This is F\#-literate-specific and corresponds to
+\texttt{{\textbackslash}begin\{equation\}...{\textbackslash}end\{equation\}}.
+
+\end{enumerate}
+
+
+
+For example
+\begin{lstlisting}
+$$\frac{x}{y}$$
+
+\begin{equation}
+ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}
+\end{equation}
+
+\end{lstlisting}
+
+
+Becomes
+
+
+\begin{equation}
+\frac{x}{y}
+\end{equation}
+
+
+
+
+\begin{equation}
+ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}
+\end{equation}
+
+
+
+
+The LaTeX will also be used in HTML and iPython notebook outputs.
+\subsubsection*{Making literate scripts work for different outputs}
+
+
+
+Literate scripts and markdown can by turned into LaTex, Python Notebooks and F\# scripts.
+
+
+A header may be needed to get the code to load, a typical example is this:
+\begin{lstlisting}
+ (*** condition: prepare ***)
+ #nowarn "211"
+ #I "../src/FSharp.Formatting/bin/Release/netstandard2.1"
+ #r "FSharp.Formatting.Common.dll"
+ #r "FSharp.Formatting.Markdown.dll"
+ #r "FSharp.Formatting.CodeFormat.dll"
+ #r "FSharp.Formatting.Literate.dll"
+ (*** condition: fsx ***)
+#if FSX
+ #r "nuget: FSharp.Formatting,1.0.0"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,1.0.0"
+#endif // IPYNB
+
+\end{lstlisting}
+\subsubsection*{Processing literate files programatically}
+
+
+
+To process file Use the two static methods to turn single documents into HTML
+as follows using functionality from the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html}{Literate} type:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{open} \id{System}{.}\id{IO}
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{Literate}
+
+\kwd{let} \id{source} \ops{=} \kwd{\_\_SOURCE\_DIRECTORY\_\_}
+\kwd{let} \id{template} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"template.html"}{)}
+
+\kwd{let} \id{script} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"../docs/script.fsx"}{)}
+
+\ltyp{Literate}{.}\id{ConvertScriptFile}{(}\id{script}{,} \id{template}{)}
+
+\kwd{let} \id{doc} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"../docs/document.md"}{)}
+
+\ltyp{Literate}{.}\id{ConvertMarkdownFile}{(}\id{doc}{,} \id{template}{)}
+
+\end{lstlisting}
+
+
+
+The following sample also uses optional parameter \texttt{parameters} to specify additional
+keywords that will be replaced in the template file (this matches the \texttt{template-project.html}
+file which is included as a sample in the package):
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{// Load the template \& specify project information}
+\kwd{let} \id{projTemplate} \ops{=} \id{source} \ops{+} \str{"template-project.html"}
+
+\kwd{let} \id{projInfo} \ops{=}
+ {[} \str{"fsdocs-authors"}{,} \str{"Tomas Petricek"}
+ \str{"fsdocs-source-link"}{,} \str{"https://github.com/fsprojects/FSharp.Formatting"}
+ \str{"fsdocs-collection-name"}{,} \str{"F\# Formatting"} {]}
+
+\end{lstlisting}
+
+
+
+The methods used above (\href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html\#ConvertScriptFile}{Literate.ConvertScriptFile}, \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html\#ConvertMarkdownFile}{Literate.ConvertMarkdownFile})
+produce HTML output by default, but they can be also used to produce LaTeX output. This is done
+by setting the output kind. The following
+example shows how to call the methods to generate LaTeX documents:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{templateTex} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"template.tex"}{)}
+
+\kwd{let} \id{scriptTex} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"../docs/script.fsx"}{)}
+
+\ltyp{Literate}{.}\id{ConvertScriptFile}{(}\id{scriptTex}{,} \id{templateTex}{,} \lfun{outputKind} \ops{=} \ltyp{OutputKind}{.}\id{Latex}{)}
+
+\kwd{let} \id{docTex} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"../docs/document.md"}{)}
+
+\ltyp{Literate}{.}\id{ConvertMarkdownFile}{(}\id{docTex}{,} \id{templateTex}{,} \lfun{outputKind} \ops{=} \ltyp{OutputKind}{.}\id{Latex}{)}
+
+\end{lstlisting}
+
+
+
+The methods used above (\texttt{ConvertScriptFile}, \texttt{ConvertMarkdownFile})
+can also produce iPython Notebook output. This is done
+by setting the named parameter \texttt{format} to \texttt{OutputKind.Pynb}:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{// Process script file, Markdown document and a directory}
+\kwd{let} \id{scriptPynb} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"../docs/script.fsx"}{)}
+
+\ltyp{Literate}{.}\id{ConvertScriptFile}{(}\id{scriptPynb}{,} \lfun{outputKind} \ops{=} \ltyp{OutputKind}{.}\id{Pynb}{)}
+
+\kwd{let} \id{docPynb} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{source}{,} \str{"../docs/document.md"}{)}
+
+\ltyp{Literate}{.}\id{ConvertMarkdownFile}{(}\id{docPynb}{,} \lfun{outputKind} \ops{=} \ltyp{OutputKind}{.}\id{Pynb}{)}
+
+\end{lstlisting}
+
+
+
+All of the three methods discussed in the previous two sections take a number of optional
+parameters that can be used to tweak how the formatting works
+
+
+\end{document}
\ No newline at end of file
diff --git a/markdown.fsx b/markdown.fsx
new file mode 100644
index 000000000..94f062266
--- /dev/null
+++ b/markdown.fsx
@@ -0,0 +1,154 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,1.0.0"
+(**
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=markdown.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//markdown.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//markdown.ipynb)
+
+# Markdown parser
+
+This page demonstrates how to use `FSharp.Formatting.Markdown` to parse a Markdown
+document, process the obtained document representation and
+how to turn the code into a nicely formatted HTML.
+
+First, we need to load the assembly and open necessary namespaces:
+
+*)
+open FSharp.Formatting.Markdown
+open FSharp.Formatting.Common
+(**
+## Parsing documents
+
+The F# Markdown parser recognizes the standard [Markdown syntax](http://daringfireball.net/projects/markdown/)
+and it is not the aim of this tutorial to fully document it.
+The following snippet creates a simple string containing a document
+with several elements and then parses it using the [Markdown.Parse](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#Parse) method:
+
+*)
+let document =
+ """
+# F# Hello world
+Hello world in [F#](http://fsharp.net) looks like this:
+
+ printfn "Hello world!"
+
+For more see [fsharp.org][fsorg].
+
+ [fsorg]: http://fsharp.org "The F# organization." """
+
+let parsed = Markdown.Parse(document)
+(**
+The sample document consists of a first-level heading (written using
+one of the two alternative styles) followed by a paragraph with a
+**direct** link, code snippet and one more paragraph that includes an
+**indirect** link. The URLs of indirect links are defined by a separate
+block as demonstrated on the last line (and they can then be easily used repeatedly
+from multiple places in the document).
+
+## Working with parsed documents
+
+The F# Markdown processor does not turn the document directly into HTML.
+Instead, it builds a nice F# data structure that we can use to analyze,
+transform and process the document. First of all the [MarkdownDocument.DefinedLinks](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#DefinedLinks) property
+returns all indirect link definitions:
+
+*)
+parsed.DefinedLinks
+// [fsi:val it : IDictionary =]
+// [fsi: dict [("fsorg", ("http://fsharp.org", Some "The F# organization."))]]
+(**
+The document content can be accessed using the [MarkdownDocument.Paragraphs](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#Paragraphs) property that returns
+a sequence of paragraphs or other first-level elements (headings, quotes, code snippets, etc.).
+The following snippet prints the heading of the document:
+
+*)
+// Iterate over all the paragraph elements
+for par in parsed.Paragraphs do
+ match par with
+ | Heading (size = 1; body = [ Literal (text = text) ]) ->
+ // Recognize heading that has a simple content
+ // containing just a literal (no other formatting)
+ printfn "%s" text
+ | _ -> ()
+(**
+You can find more detailed information about the document structure and how to process it
+in the book [F# Deep Dives](http://manning.com/petricek2/).
+
+## Processing the document recursively
+
+The library provides active patterns that can be used to easily process the Markdown
+document recursively. The example in this section shows how to extract all links from the
+document. To do that, we need to write two recursive functions. One that will process
+all paragraph-style elements and one that will process all inline formattings (inside
+paragraphs, headings etc.).
+
+To avoid pattern matching on every single kind of span and every single kind of
+paragraph, we can use active patterns from the [MarkdownPatterns](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html) module. These can be use
+to recognize any paragraph or span that can contain child elements:
+
+*)
+/// Returns all links in a specified span node
+let rec collectSpanLinks span =
+ seq {
+ match span with
+ | DirectLink (link = url) -> yield url
+ | IndirectLink (key = key) -> yield fst (parsed.DefinedLinks.[key])
+ | MarkdownPatterns.SpanLeaf _ -> ()
+ | MarkdownPatterns.SpanNode (_, spans) ->
+ for s in spans do
+ yield! collectSpanLinks s
+ }
+
+/// Returns all links in the specified paragraph node
+let rec collectParLinks par =
+ seq {
+ match par with
+ | MarkdownPatterns.ParagraphLeaf _ -> ()
+ | MarkdownPatterns.ParagraphNested (_, pars) ->
+ for ps in pars do
+ for p in ps do
+ yield! collectParLinks p
+ | MarkdownPatterns.ParagraphSpans (_, spans) ->
+ for s in spans do
+ yield! collectSpanLinks s
+ }
+
+// Collect links in the entire document
+Seq.collect collectParLinks parsed.Paragraphs
+// [fsi:val it : seq =]
+// [fsi: seq ["http://fsharp.net"; "http://fsharp.org"]]
+(**
+The `collectSpanLinks` function works on individual span elements that contain inline
+formatting (emphasis, strong) and also links. The `DirectLink` node from [MarkdownSpan](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html) represents an inline
+link like the one pointing to [http://fsharp.net](http://fsharp.net) while `IndirectLink` represents a
+link that uses one of the link definitions. The function simply returns the URL associated
+with the link.
+
+Some span nodes (like emphasis) can contain other formatting, so we need to recursively
+process children. This is done by matching against `MarkdownPatterns.SpanNodes` which is an active
+pattern that recognizes any node with children. The library also provides a **function**
+named `MarkdownPatterns.SpanNode` that can be used to reconstruct the same node (when you want
+to transform document). This is similar to how the `ExprShape` module for working with
+F# quotations works.
+
+The function `collectParLinks` processes paragraphs - a paragraph cannot directly be a
+link so we just need to process all spans. This time, there are three options.
+`ParagraphLeaf` represents a case where the paragraph does not contain any spans
+(a code block or, for example, a `` line); the `ParagraphNested` case is used for paragraphs
+that contain other paragraphs (quotation) and `ParagraphSpans` is used for all other
+paragraphs that contain normal text - here we call `collectSpanLinks` on all nested spans.
+
+## Generating HTML output
+
+Finally, the [Markdown](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html) type also includes a method [Markdown.ToHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml) that can be used
+to generate an HTML document from the Markdown input. The following example shows how to call it:
+
+*)
+let html = Markdown.ToHtml(parsed)
+(**
+There are also methods to generate `.fsx`, `.ipynb`, `.md` and `.tex`.
+
+*)
+
diff --git a/markdown.html b/markdown.html
new file mode 100644
index 000000000..33b0f6271
--- /dev/null
+++ b/markdown.html
@@ -0,0 +1,528 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown parser
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This page demonstrates how to use FSharp.Formatting.Markdown to parse a Markdown
+document, process the obtained document representation and
+how to turn the code into a nicely formatted HTML.
+
First, we need to load the assembly and open necessary namespaces:
The F# Markdown parser recognizes the standard Markdown syntax
+and it is not the aim of this tutorial to fully document it.
+The following snippet creates a simple string containing a document
+with several elements and then parses it using the Markdown.Parse method:
+
letdocument=
+ """
+# F# Hello world
+Hello world in [F#](http://fsharp.net) looks like this:
+
+ printfn "Hello world!"
+
+For more see [fsharp.org][fsorg].
+
+ [fsorg]: http://fsharp.org "The F# organization." """
+
+letparsed=Markdown.Parse(document)
+
+
The sample document consists of a first-level heading (written using
+one of the two alternative styles) followed by a paragraph with a
+direct link, code snippet and one more paragraph that includes an
+indirect link. The URLs of indirect links are defined by a separate
+block as demonstrated on the last line (and they can then be easily used repeatedly
+from multiple places in the document).
The F# Markdown processor does not turn the document directly into HTML.
+Instead, it builds a nice F# data structure that we can use to analyze,
+transform and process the document. First of all the MarkdownDocument.DefinedLinks property
+returns all indirect link definitions:
+
parsed.DefinedLinks
+val it : IDictionary<string,(string * string option)> =
+ dict [("fsorg", ("http://fsharp.org", Some "The F# organization."))]
+
+
The document content can be accessed using the MarkdownDocument.Paragraphs property that returns
+a sequence of paragraphs or other first-level elements (headings, quotes, code snippets, etc.).
+The following snippet prints the heading of the document:
+
// Iterate over all the paragraph elements
+forparinparsed.Paragraphsdo
+ matchparwith
+ |Heading(size=1;body=[Literal(text=text)])->
+ // Recognize heading that has a simple content
+ // containing just a literal (no other formatting)
+ printfn"%s"text
+ |_->()
+
+
You can find more detailed information about the document structure and how to process it
+in the book F# Deep Dives.
The library provides active patterns that can be used to easily process the Markdown
+document recursively. The example in this section shows how to extract all links from the
+document. To do that, we need to write two recursive functions. One that will process
+all paragraph-style elements and one that will process all inline formattings (inside
+paragraphs, headings etc.).
+
To avoid pattern matching on every single kind of span and every single kind of
+paragraph, we can use active patterns from the MarkdownPatterns module. These can be use
+to recognize any paragraph or span that can contain child elements:
+
/// Returns all links in a specified span node
+letreccollectSpanLinksspan=
+ seq{
+ matchspanwith
+ |DirectLink(link=url)->yieldurl
+ |IndirectLink(key=key)->yieldfst(parsed.DefinedLinks.[key])
+ |MarkdownPatterns.SpanLeaf_->()
+ |MarkdownPatterns.SpanNode(_,spans)->
+ forsinspansdo
+ yield!collectSpanLinkss
+ }
+
+/// Returns all links in the specified paragraph node
+letreccollectParLinkspar=
+ seq{
+ matchparwith
+ |MarkdownPatterns.ParagraphLeaf_->()
+ |MarkdownPatterns.ParagraphNested(_,pars)->
+ forpsinparsdo
+ forpinpsdo
+ yield!collectParLinksp
+ |MarkdownPatterns.ParagraphSpans(_,spans)->
+ forsinspansdo
+ yield!collectSpanLinkss
+ }
+
+// Collect links in the entire document
+Seq.collectcollectParLinksparsed.Paragraphs
+val it : seq<string> =
+ seq ["http://fsharp.net"; "http://fsharp.org"]
+
+
The collectSpanLinks function works on individual span elements that contain inline
+formatting (emphasis, strong) and also links. The DirectLink node from MarkdownSpan represents an inline
+link like the one pointing to http://fsharp.net while IndirectLink represents a
+link that uses one of the link definitions. The function simply returns the URL associated
+with the link.
+
Some span nodes (like emphasis) can contain other formatting, so we need to recursively
+process children. This is done by matching against MarkdownPatterns.SpanNodes which is an active
+pattern that recognizes any node with children. The library also provides a function
+named MarkdownPatterns.SpanNode that can be used to reconstruct the same node (when you want
+to transform document). This is similar to how the ExprShape module for working with
+F# quotations works.
+
The function collectParLinks processes paragraphs - a paragraph cannot directly be a
+link so we just need to process all spans. This time, there are three options.
+ParagraphLeaf represents a case where the paragraph does not contain any spans
+(a code block or, for example, a <hr> line); the ParagraphNested case is used for paragraphs
+that contain other paragraphs (quotation) and ParagraphSpans is used for all other
+paragraphs that contain normal text - here we call collectSpanLinks on all nested spans.
Finally, the Markdown type also includes a method Markdown.ToHtml that can be used
+to generate an HTML document from the Markdown input. The following example shows how to call it:
+
lethtml=Markdown.ToHtml(parsed)
+
+
There are also methods to generate .fsx, .ipynb, .md and .tex.
property MarkdownDocument.DefinedLinks: System.Collections.Generic.IDictionary<string,(string * string option)> with get <summary>
+ Returns a dictionary containing explicitly defined links
+</summary>
+
val par: MarkdownParagraph
+
property MarkdownDocument.Paragraphs: MarkdownParagraphs with get <summary>
+ Returns a list of paragraphs in the document
+</summary>
+
union case MarkdownParagraph.Heading: size: int * body: MarkdownSpans * range: MarkdownRange option -> MarkdownParagraph
+
Multiple items union case MarkdownSpan.Literal: text: string * range: MarkdownRange option -> MarkdownSpan
-------------------- type LiteralAttribute =
+ inherit Attribute
+ new: unit -> LiteralAttribute
-------------------- new: unit -> LiteralAttribute
+
val text: string
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
val collectSpanLinks: span: MarkdownSpan -> string seq Returns all links in a specified span node
+
val span: MarkdownSpan
+
Multiple items val seq: sequence: 'T seq -> 'T seq
-------------------- type 'T seq = System.Collections.Generic.IEnumerable<'T>
+
union case MarkdownSpan.DirectLink: body: MarkdownSpans * link: string * title: string option * range: MarkdownRange option -> MarkdownSpan
+
val url: string
+
union case MarkdownSpan.IndirectLink: body: MarkdownSpans * original: string * key: string * range: MarkdownRange option -> MarkdownSpan
+
val key: string
+
val fst: tuple: ('T1 * 'T2) -> 'T1
+
module MarkdownPatterns
+
+from FSharp.Formatting.Markdown <summary>
+ This module provides an easy way of processing Markdown documents.
+ It lets you decompose documents into leafs and nodes with nested paragraphs.
+</summary>
+
Multiple items val SpanLeaf: MarkdownPatterns.SpanLeafInfo -> MarkdownSpan
-------------------- active recognizer SpanLeaf: MarkdownSpan -> Choice<MarkdownPatterns.SpanLeafInfo,(MarkdownPatterns.SpanNodeInfo * MarkdownSpans)>
+
Multiple items val SpanNode: MarkdownPatterns.SpanNodeInfo * spans: MarkdownSpans -> MarkdownSpan
-------------------- active recognizer SpanNode: MarkdownSpan -> Choice<MarkdownPatterns.SpanLeafInfo,(MarkdownPatterns.SpanNodeInfo * MarkdownSpans)>
+
val spans: MarkdownSpans
+
val s: MarkdownSpan
+
val collectParLinks: par: MarkdownParagraph -> string seq Returns all links in the specified paragraph node
+
Multiple items val ParagraphLeaf: MarkdownPatterns.ParagraphLeafInfo -> MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/markdown.ipynb b/markdown.ipynb
new file mode 100644
index 000000000..d55a91592
--- /dev/null
+++ b/markdown.ipynb
@@ -0,0 +1,338 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "#r \"nuget: FSharp.Formatting,1.0.0\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=markdown.ipynb)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//markdown.fsx)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//markdown.ipynb)\n",
+ "\n",
+ "# Markdown parser\n",
+ "\n",
+ "This page demonstrates how to use `FSharp.Formatting.Markdown` to parse a Markdown\n",
+ "document, process the obtained document representation and\n",
+ "how to turn the code into a nicely formatted HTML.\n",
+ "\n",
+ "First, we need to load the assembly and open necessary namespaces:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "open FSharp.Formatting.Markdown\n",
+ "open FSharp.Formatting.Common\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "## Parsing documents\n",
+ "\n",
+ "The F# Markdown parser recognizes the standard [Markdown syntax](http://daringfireball.net/projects/markdown/)\n",
+ "and it is not the aim of this tutorial to fully document it.\n",
+ "The following snippet creates a simple string containing a document\n",
+ "with several elements and then parses it using the [Markdown.Parse](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#Parse) method:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let document =\n",
+ " \"\"\"\n",
+ "# F# Hello world\n",
+ "Hello world in [F#](http://fsharp.net) looks like this:\n",
+ "\n",
+ " printfn \"Hello world!\"\n",
+ "\n",
+ "For more see [fsharp.org][fsorg].\n",
+ "\n",
+ " [fsorg]: http://fsharp.org \"The F# organization.\" \"\"\"\n",
+ "\n",
+ "let parsed = Markdown.Parse(document)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The sample document consists of a first-level heading (written using\n",
+ "one of the two alternative styles) followed by a paragraph with a\n",
+ "**direct** link, code snippet and one more paragraph that includes an\n",
+ "**indirect** link. The URLs of indirect links are defined by a separate\n",
+ "block as demonstrated on the last line (and they can then be easily used repeatedly\n",
+ "from multiple places in the document).\n",
+ "\n",
+ "## Working with parsed documents\n",
+ "\n",
+ "The F# Markdown processor does not turn the document directly into HTML.\n",
+ "Instead, it builds a nice F# data structure that we can use to analyze,\n",
+ "transform and process the document. First of all the [MarkdownDocument.DefinedLinks](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#DefinedLinks) property\n",
+ "returns all indirect link definitions:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "parsed.DefinedLinks\n",
+ "// [fsi:val it : IDictionary\u003cstring,(string * string option)\u003e =]\n",
+ "// [fsi: dict [(\"fsorg\", (\"http://fsharp.org\", Some \"The F# organization.\"))]]\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The document content can be accessed using the [MarkdownDocument.Paragraphs](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#Paragraphs) property that returns\n",
+ "a sequence of paragraphs or other first-level elements (headings, quotes, code snippets, etc.).\n",
+ "The following snippet prints the heading of the document:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "// Iterate over all the paragraph elements\n",
+ "for par in parsed.Paragraphs do\n",
+ " match par with\n",
+ " | Heading (size = 1; body = [ Literal (text = text) ]) -\u003e\n",
+ " // Recognize heading that has a simple content\n",
+ " // containing just a literal (no other formatting)\n",
+ " printfn \"%s\" text\n",
+ " | _ -\u003e ()\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "You can find more detailed information about the document structure and how to process it\n",
+ "in the book [F# Deep Dives](http://manning.com/petricek2/).\n",
+ "\n",
+ "## Processing the document recursively\n",
+ "\n",
+ "The library provides active patterns that can be used to easily process the Markdown\n",
+ "document recursively. The example in this section shows how to extract all links from the\n",
+ "document. To do that, we need to write two recursive functions. One that will process\n",
+ "all paragraph-style elements and one that will process all inline formattings (inside\n",
+ "paragraphs, headings etc.).\n",
+ "\n",
+ "To avoid pattern matching on every single kind of span and every single kind of\n",
+ "paragraph, we can use active patterns from the [MarkdownPatterns](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html) module. These can be use\n",
+ "to recognize any paragraph or span that can contain child elements:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// Returns all links in a specified span node\n",
+ "let rec collectSpanLinks span =\n",
+ " seq {\n",
+ " match span with\n",
+ " | DirectLink (link = url) -\u003e yield url\n",
+ " | IndirectLink (key = key) -\u003e yield fst (parsed.DefinedLinks.[key])\n",
+ " | MarkdownPatterns.SpanLeaf _ -\u003e ()\n",
+ " | MarkdownPatterns.SpanNode (_, spans) -\u003e\n",
+ " for s in spans do\n",
+ " yield! collectSpanLinks s\n",
+ " }\n",
+ "\n",
+ "/// Returns all links in the specified paragraph node\n",
+ "let rec collectParLinks par =\n",
+ " seq {\n",
+ " match par with\n",
+ " | MarkdownPatterns.ParagraphLeaf _ -\u003e ()\n",
+ " | MarkdownPatterns.ParagraphNested (_, pars) -\u003e\n",
+ " for ps in pars do\n",
+ " for p in ps do\n",
+ " yield! collectParLinks p\n",
+ " | MarkdownPatterns.ParagraphSpans (_, spans) -\u003e\n",
+ " for s in spans do\n",
+ " yield! collectSpanLinks s\n",
+ " }\n",
+ "\n",
+ "// Collect links in the entire document\n",
+ "Seq.collect collectParLinks parsed.Paragraphs\n",
+ "// [fsi:val it : seq\u003cstring\u003e =]\n",
+ "// [fsi: seq [\"http://fsharp.net\"; \"http://fsharp.org\"]]\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The `collectSpanLinks` function works on individual span elements that contain inline\n",
+ "formatting (emphasis, strong) and also links. The `DirectLink` node from [MarkdownSpan](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html) represents an inline\n",
+ "link like the one pointing to [http://fsharp.net](http://fsharp.net) while `IndirectLink` represents a\n",
+ "link that uses one of the link definitions. The function simply returns the URL associated\n",
+ "with the link.\n",
+ "\n",
+ "Some span nodes (like emphasis) can contain other formatting, so we need to recursively\n",
+ "process children. This is done by matching against `MarkdownPatterns.SpanNodes` which is an active\n",
+ "pattern that recognizes any node with children. The library also provides a **function**\n",
+ "named `MarkdownPatterns.SpanNode` that can be used to reconstruct the same node (when you want\n",
+ "to transform document). This is similar to how the `ExprShape` module for working with\n",
+ "F# quotations works.\n",
+ "\n",
+ "The function `collectParLinks` processes paragraphs - a paragraph cannot directly be a\n",
+ "link so we just need to process all spans. This time, there are three options.\n",
+ "`ParagraphLeaf` represents a case where the paragraph does not contain any spans\n",
+ "(a code block or, for example, a `\u003chr\u003e` line); the `ParagraphNested` case is used for paragraphs\n",
+ "that contain other paragraphs (quotation) and `ParagraphSpans` is used for all other\n",
+ "paragraphs that contain normal text - here we call `collectSpanLinks` on all nested spans.\n",
+ "\n",
+ "## Generating HTML output\n",
+ "\n",
+ "Finally, the [Markdown](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html) type also includes a method [Markdown.ToHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml) that can be used\n",
+ "to generate an HTML document from the Markdown input. The following example shows how to call it:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let html = Markdown.ToHtml(parsed)\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "There are also methods to generate `.fsx`, `.ipynb`, `.md` and `.tex`.\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/markdown.md b/markdown.md
new file mode 100644
index 000000000..79e7acee6
--- /dev/null
+++ b/markdown.md
@@ -0,0 +1,154 @@
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=markdown.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//markdown.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//markdown.ipynb)
+
+# Markdown parser
+
+This page demonstrates how to use `FSharp.Formatting.Markdown` to parse a Markdown
+document, process the obtained document representation and
+how to turn the code into a nicely formatted HTML.
+
+First, we need to load the assembly and open necessary namespaces:
+
+```fsharp
+open FSharp.Formatting.Markdown
+open FSharp.Formatting.Common
+```
+
+## Parsing documents
+
+The F# Markdown parser recognizes the standard [Markdown syntax](http://daringfireball.net/projects/markdown/)
+and it is not the aim of this tutorial to fully document it.
+The following snippet creates a simple string containing a document
+with several elements and then parses it using the [Markdown.Parse](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#Parse) method:
+
+```fsharp
+let document =
+ """
+# F# Hello world
+Hello world in [F#](http://fsharp.net) looks like this:
+
+ printfn "Hello world!"
+
+For more see [fsharp.org][fsorg].
+
+ [fsorg]: http://fsharp.org "The F# organization." """
+
+let parsed = Markdown.Parse(document)
+```
+
+The sample document consists of a first-level heading (written using
+one of the two alternative styles) followed by a paragraph with a
+**direct** link, code snippet and one more paragraph that includes an
+**indirect** link. The URLs of indirect links are defined by a separate
+block as demonstrated on the last line (and they can then be easily used repeatedly
+from multiple places in the document).
+
+## Working with parsed documents
+
+The F# Markdown processor does not turn the document directly into HTML.
+Instead, it builds a nice F# data structure that we can use to analyze,
+transform and process the document. First of all the [MarkdownDocument.DefinedLinks](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#DefinedLinks) property
+returns all indirect link definitions:
+
+```fsharp
+parsed.DefinedLinks
+// [fsi:val it : IDictionary =]
+// [fsi: dict [("fsorg", ("http://fsharp.org", Some "The F# organization."))]]
+```
+
+The document content can be accessed using the [MarkdownDocument.Paragraphs](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#Paragraphs) property that returns
+a sequence of paragraphs or other first-level elements (headings, quotes, code snippets, etc.).
+The following snippet prints the heading of the document:
+
+```fsharp
+// Iterate over all the paragraph elements
+for par in parsed.Paragraphs do
+ match par with
+ | Heading (size = 1; body = [ Literal (text = text) ]) ->
+ // Recognize heading that has a simple content
+ // containing just a literal (no other formatting)
+ printfn "%s" text
+ | _ -> ()
+```
+
+You can find more detailed information about the document structure and how to process it
+in the book [F# Deep Dives](http://manning.com/petricek2/).
+
+## Processing the document recursively
+
+The library provides active patterns that can be used to easily process the Markdown
+document recursively. The example in this section shows how to extract all links from the
+document. To do that, we need to write two recursive functions. One that will process
+all paragraph-style elements and one that will process all inline formattings (inside
+paragraphs, headings etc.).
+
+To avoid pattern matching on every single kind of span and every single kind of
+paragraph, we can use active patterns from the [MarkdownPatterns](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html) module. These can be use
+to recognize any paragraph or span that can contain child elements:
+
+```fsharp
+/// Returns all links in a specified span node
+let rec collectSpanLinks span =
+ seq {
+ match span with
+ | DirectLink (link = url) -> yield url
+ | IndirectLink (key = key) -> yield fst (parsed.DefinedLinks.[key])
+ | MarkdownPatterns.SpanLeaf _ -> ()
+ | MarkdownPatterns.SpanNode (_, spans) ->
+ for s in spans do
+ yield! collectSpanLinks s
+ }
+
+/// Returns all links in the specified paragraph node
+let rec collectParLinks par =
+ seq {
+ match par with
+ | MarkdownPatterns.ParagraphLeaf _ -> ()
+ | MarkdownPatterns.ParagraphNested (_, pars) ->
+ for ps in pars do
+ for p in ps do
+ yield! collectParLinks p
+ | MarkdownPatterns.ParagraphSpans (_, spans) ->
+ for s in spans do
+ yield! collectSpanLinks s
+ }
+
+// Collect links in the entire document
+Seq.collect collectParLinks parsed.Paragraphs
+// [fsi:val it : seq =]
+// [fsi: seq ["http://fsharp.net"; "http://fsharp.org"]]
+```
+
+The `collectSpanLinks` function works on individual span elements that contain inline
+formatting (emphasis, strong) and also links. The `DirectLink` node from [MarkdownSpan](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html) represents an inline
+link like the one pointing to [http://fsharp.net](http://fsharp.net) while `IndirectLink` represents a
+link that uses one of the link definitions. The function simply returns the URL associated
+with the link.
+
+Some span nodes (like emphasis) can contain other formatting, so we need to recursively
+process children. This is done by matching against `MarkdownPatterns.SpanNodes` which is an active
+pattern that recognizes any node with children. The library also provides a **function**
+named `MarkdownPatterns.SpanNode` that can be used to reconstruct the same node (when you want
+to transform document). This is similar to how the `ExprShape` module for working with
+F# quotations works.
+
+The function `collectParLinks` processes paragraphs - a paragraph cannot directly be a
+link so we just need to process all spans. This time, there are three options.
+`ParagraphLeaf` represents a case where the paragraph does not contain any spans
+(a code block or, for example, a `` line); the `ParagraphNested` case is used for paragraphs
+that contain other paragraphs (quotation) and `ParagraphSpans` is used for all other
+paragraphs that contain normal text - here we call `collectSpanLinks` on all nested spans.
+
+## Generating HTML output
+
+Finally, the [Markdown](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html) type also includes a method [Markdown.ToHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml) that can be used
+to generate an HTML document from the Markdown input. The following example shows how to call it:
+
+```fsharp
+let html = Markdown.ToHtml(parsed)
+```
+
+There are also methods to generate `.fsx`, `.ipynb`, `.md` and `.tex`.
+
+
diff --git a/markdown.tex b/markdown.tex
new file mode 100644
index 000000000..87924a46a
--- /dev/null
+++ b/markdown.tex
@@ -0,0 +1,247 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+
+
+\href{https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=markdown.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-binder.svg}
+\caption{Binder}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//markdown.fsx}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-script.svg}
+\caption{Script}
+\end{figure}
+}
+\href{https://fsprojects.github.io/FSharp.Formatting//markdown.ipynb}{\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{img/badge-notebook.svg}
+\caption{Notebook}
+\end{figure}
+}
+\section*{Markdown parser}
+
+
+
+This page demonstrates how to use \texttt{FSharp.Formatting.Markdown} to parse a Markdown
+document, process the obtained document representation and
+how to turn the code into a nicely formatted HTML.
+
+
+First, we need to load the assembly and open necessary namespaces:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{Markdown}
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{Common}
+
+\end{lstlisting}
+
+\subsection*{Parsing documents}
+
+
+
+The F\# Markdown parser recognizes the standard \href{http://daringfireball.net/projects/markdown/}{Markdown syntax}
+and it is not the aim of this tutorial to fully document it.
+The following snippet creates a simple string containing a document
+with several elements and then parses it using the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html\#Parse}{Markdown.Parse} method:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{document} \ops{=}
+ \str{"""}
+\str{\# F\# Hello world}
+\str{Hello world in [F\#](http://fsharp.net) looks like this:}
+
+\str{ printfn "Hello world!"}
+
+\str{For more see [fsharp.org][fsorg].}
+
+\str{ [fsorg]: http://fsharp.org "The F\# organization." """}
+
+\kwd{let} \id{parsed} \ops{=} \ltyp{Markdown}{.}\id{Parse}{(}\id{document}{)}
+
+\end{lstlisting}
+
+
+
+The sample document consists of a first-level heading (written using
+one of the two alternative styles) followed by a paragraph with a
+\emph{direct} link, code snippet and one more paragraph that includes an
+\emph{indirect} link. The URLs of indirect links are defined by a separate
+block as demonstrated on the last line (and they can then be easily used repeatedly
+from multiple places in the document).
+\subsection*{Working with parsed documents}
+
+
+
+The F\# Markdown processor does not turn the document directly into HTML.
+Instead, it builds a nice F\# data structure that we can use to analyze,
+transform and process the document. First of all the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html\#DefinedLinks}{MarkdownDocument.DefinedLinks} property
+returns all indirect link definitions:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\id{parsed}{.}\id{DefinedLinks}
+\fsi{val it : IDictionary =}
+\fsi{ dict [("fsorg", ("http://fsharp.org", Some "The F\# organization."))]}
+
+\end{lstlisting}
+
+
+
+The document content can be accessed using the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html\#Paragraphs}{MarkdownDocument.Paragraphs} property that returns
+a sequence of paragraphs or other first-level elements (headings, quotes, code snippets, etc.).
+The following snippet prints the heading of the document:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{// Iterate over all the paragraph elements}
+\kwd{for} \lfun{par} \kwd{in} \id{parsed}{.}\id{Paragraphs} \kwd{do}
+ \kwd{match} \lfun{par} \kwd{with}
+ {|} {Heading} {(}{size} \ops{=} \num{1}{;} {body} \ops{=} {[} {Literal} {(}{text} \ops{=} \lfun{text}{)} {]}{)} \kwd{->}
+ \com{// Recognize heading that has a simple content}
+ \com{// containing just a literal (no other formatting)}
+ \lfun{printfn} \str{"}\lprf{\%s}\str{"} \lfun{text}
+ {|} \id{\_} \kwd{->} {(}{)}
+
+\end{lstlisting}
+
+
+
+You can find more detailed information about the document structure and how to process it
+in the book \href{http://manning.com/petricek2/}{F\# Deep Dives}.
+\subsection*{Processing the document recursively}
+
+
+
+The library provides active patterns that can be used to easily process the Markdown
+document recursively. The example in this section shows how to extract all links from the
+document. To do that, we need to write two recursive functions. One that will process
+all paragraph-style elements and one that will process all inline formattings (inside
+paragraphs, headings etc.).
+
+
+To avoid pattern matching on every single kind of span and every single kind of
+paragraph, we can use active patterns from the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html}{MarkdownPatterns} module. These can be use
+to recognize any paragraph or span that can contain child elements:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// Returns all links in a specified span node}
+\kwd{let} \kwd{rec} \lfun{collectSpanLinks} \lfun{span} \ops{=}
+ \lfun{seq} {\{}
+ \kwd{match} \lfun{span} \kwd{with}
+ {|} {DirectLink} {(}{link} \ops{=} \lfun{url}{)} \kwd{->} \kwd{yield} \lfun{url}
+ {|} {IndirectLink} {(}{key} \ops{=} \lfun{key}{)} \kwd{->} \kwd{yield} \lfun{fst} {(}\id{parsed}{.}\id{DefinedLinks}{.}{[}\lfun{key}{]}{)}
+ {|} \ltyp{MarkdownPatterns}{.}\id{SpanLeaf} \id{\_} \kwd{->} {(}{)}
+ {|} \ltyp{MarkdownPatterns}{.}\id{SpanNode} {(}\id{\_}{,} \lfun{spans}{)} \kwd{->}
+ \kwd{for} \lfun{s} \kwd{in} \lfun{spans} \kwd{do}
+ \kwd{yield!} \lfun{collectSpanLinks} \lfun{s}
+ {\}}
+
+\com{/// Returns all links in the specified paragraph node}
+\kwd{let} \kwd{rec} \lfun{collectParLinks} \lfun{par} \ops{=}
+ \lfun{seq} {\{}
+ \kwd{match} \lfun{par} \kwd{with}
+ {|} \ltyp{MarkdownPatterns}{.}\id{ParagraphLeaf} \id{\_} \kwd{->} {(}{)}
+ {|} \ltyp{MarkdownPatterns}{.}\id{ParagraphNested} {(}\id{\_}{,} \lfun{pars}{)} \kwd{->}
+ \kwd{for} \lfun{ps} \kwd{in} \lfun{pars} \kwd{do}
+ \kwd{for} \lfun{p} \kwd{in} \lfun{ps} \kwd{do}
+ \kwd{yield!} \lfun{collectParLinks} \lfun{p}
+ {|} \ltyp{MarkdownPatterns}{.}\id{ParagraphSpans} {(}\id{\_}{,} \lfun{spans}{)} \kwd{->}
+ \kwd{for} \lfun{s} \kwd{in} \lfun{spans} \kwd{do}
+ \kwd{yield!} \lfun{collectSpanLinks} \lfun{s}
+ {\}}
+
+\com{// Collect links in the entire document}
+\ltyp{Seq}{.}\id{collect} \lfun{collectParLinks} \id{parsed}{.}\id{Paragraphs}
+\fsi{val it : seq =}
+\fsi{ seq ["http://fsharp.net"; "http://fsharp.org"]}
+
+\end{lstlisting}
+
+
+
+The \texttt{collectSpanLinks} function works on individual span elements that contain inline
+formatting (emphasis, strong) and also links. The \texttt{DirectLink} node from \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html}{MarkdownSpan} represents an inline
+link like the one pointing to \href{http://fsharp.net}{http://fsharp.net} while \texttt{IndirectLink} represents a
+link that uses one of the link definitions. The function simply returns the URL associated
+with the link.
+
+
+Some span nodes (like emphasis) can contain other formatting, so we need to recursively
+process children. This is done by matching against \texttt{MarkdownPatterns.SpanNodes} which is an active
+pattern that recognizes any node with children. The library also provides a \emph{function}
+named \texttt{MarkdownPatterns.SpanNode} that can be used to reconstruct the same node (when you want
+to transform document). This is similar to how the \texttt{ExprShape} module for working with
+F\# quotations works.
+
+
+The function \texttt{collectParLinks} processes paragraphs - a paragraph cannot directly be a
+link so we just need to process all spans. This time, there are three options.
+\texttt{ParagraphLeaf} represents a case where the paragraph does not contain any spans
+(a code block or, for example, a \texttt{} line); the \texttt{ParagraphNested} case is used for paragraphs
+that contain other paragraphs (quotation) and \texttt{ParagraphSpans} is used for all other
+paragraphs that contain normal text - here we call \texttt{collectSpanLinks} on all nested spans.
+\subsection*{Generating HTML output}
+
+
+
+Finally, the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html}{Markdown} type also includes a method \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html\#ToHtml}{Markdown.ToHtml} that can be used
+to generate an HTML document from the Markdown input. The following example shows how to call it:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{html} \ops{=} \ltyp{Markdown}{.}\id{ToHtml}{(}\id{parsed}{)}
+
+\end{lstlisting}
+
+
+
+There are also methods to generate \texttt{.fsx}, \texttt{.ipynb}, \texttt{.md} and \texttt{.tex}.
+
+
+\end{document}
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocattribute.html b/reference/fsharp-formatting-apidocs-apidocattribute.html
new file mode 100644
index 000000000..04cf3f1f3
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocattribute.html
@@ -0,0 +1,1298 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocAttribute (FSharp.Formatting) | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the obsolete message, when this attribute is the System.ObsoleteAttribute. When its not or no message was specified, an empty string is returned
+
+ Full Usage:
+ Substitutions
+
+
+
+ Field type:
+ Substitutions option
+
+
+
+
+
+
+
+
+
+
+
+
+ The substitutionss active for this input. If specified these
+ are used instead of the overall substitutions. This allows different parameters (e.g.
+ different authors) for each assembly in a collection.
+
+ Represents an method, property, constructor, function or value, record field, union case or static parameter
+ integrated with its associated documentation. Includes extension members.
+
+
+ This type exposes the functionality for producing documentation model from `dll` files with associated `xml` files
+ generated by the F# or C# compiler. To generate documentation model, use one of the overloades of the `Generate` method.
+
+
+
+
+ inputs
+
+ :
+ ApiDocInput list
+ -
+ the components to generate documentation for
+
+
+
+
+ output
+
+ :
+ string
+ -
+ the output directory
+
+
+
+
+ collectionName
+
+ :
+ string
+ -
+ the overall collection name
+
+
+
+
+ substitutions
+
+ :
+ Substitutions
+ -
+ the substitutions to use in content and templates
+
+
+
+
+ ?template
+
+ :
+ string
+ -
+ the template to use for each documentation page
+
+
+
+
+ ?root
+
+ :
+ string
+ -
+ The root url of the generated documentation within the website
+
+
+
+
+ ?qualify
+
+ :
+ bool
+ -
+ qualify the output set by collection name, e.g. `reference/FSharp.Core/...`
+
+
+
+
+ ?libDirs
+
+ :
+ string list
+ -
+ Use this to specify additional paths where referenced DLL files can be found when formatting code snippets inside Markdown comments
+
+
+
+
+ ?otherFlags
+
+ :
+ string list
+ -
+ Additional flags that are passed to the F# compiler to specify references explicitly etc.
+
+
+
+
+ ?urlRangeHighlight
+
+ :
+ Uri -> int -> int -> string
+ -
+ A function that can be used to override the default way of generating GitHub links
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+
+ inputs
+
+ :
+ ApiDocInput list
+ -
+ the components to generate documentation for
+
+
+
+
+ output
+
+ :
+ string
+ -
+ the output directory
+
+
+
+
+ collectionName
+
+ :
+ string
+ -
+ the overall collection name
+
+
+
+
+ substitutions
+
+ :
+ Substitutions
+ -
+ the substitutions to use in content and templates
+
+
+
+
+ ?template
+
+ :
+ string
+ -
+ the template to use for each documentation page
+
+
+
+
+ ?root
+
+ :
+ string
+ -
+ The root url of the generated documentation within the website
+
+
+
+
+ ?qualify
+
+ :
+ bool
+ -
+ qualify the output set by collection name, e.g. `reference/FSharp.Core/...`
+
+
+
+
+ ?libDirs
+
+ :
+ string list
+ -
+ Use this to specify additional paths where referenced DLL files can be found when formatting code snippets inside Markdown comments
+
+
+
+
+ ?otherFlags
+
+ :
+ string list
+ -
+ Additional flags that are passed to the F# compiler to specify references explicitly etc.
+
+
+
+
+ ?urlRangeHighlight
+
+ :
+ Uri -> int -> int -> string
+ -
+ A function that can be used to override the default way of generating GitHub links
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+
+ inputs
+
+ :
+ ApiDocInput list
+ -
+ the components to generate documentation for
+
+
+
+
+ collectionName
+
+ :
+ string
+ -
+ the overall collection name
+
+
+
+
+ substitutions
+
+ :
+ Substitutions
+ -
+ the substitutions to use in content and templates
+
+
+
+
+ ?qualify
+
+ :
+ bool
+ -
+ qualify the output set by collection name, e.g. reference/FSharp.Core/...
+
+
+
+
+ ?libDirs
+
+ :
+ string list
+ -
+ Use this to specify additional paths where referenced DLL files can be found when formatting code snippets inside Markdown comments
+
+
+
+
+ ?otherFlags
+
+ :
+ string list
+ -
+ Additional flags that are passed to the F# compiler (you can use this if you want to
+ specify references explicitly etc.)
+
+
+
+
+ ?root
+
+ :
+ string
+ -
+ The root url of the generated documentation within the website
+
+
+
+
+ ?urlRangeHighlight
+
+ :
+ Uri -> int -> int -> string
+ -
+ A function that can be used to override the default way of generating GitHub links
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+ -
+
+
+
+
+
+ ?extension
+
+ :
+ ApiDocFileExtensions
+ -
+ The extensions used for files and URLs
+
+
+
+ Represents an method, property, constructor, function or value, record field, union case or static parameter
+ integrated with its associated documentation. Includes extension members.
+
+
+ This type exposes the functionality for producing documentation model from `dll` files with associated `xml` files
+ generated by the F# or C# compiler. To generate documentation model, use one of the overloades of the `Generate` method.
+
+
+ Formats the .fsx snippets as HTML. The parameters specify prefix for HTML tags, whether lines should
+ be added to outputs and whether errors should be printed.
+
+ Parse, check and annotate the source code specified by 'source', assuming that it
+ is located in a specified 'file'. Optional arguments can be used
+ to give compiler command line options and preprocessor definitions
+
+ Error reported from the F# compiler consists of location (start and end),
+ error kind and the message (wrapped in a single case discriminated union
+ with constructor SourceError)
+
+ A token in a parsed F# code snippet. Aside from standard tokens reported from
+ the compiler (Token), this also includes Error (wrapping the underlined
+ tokens), Omitted for the special [omit:...] tags and Output for the special [output:...] tag
+
+ Error reported from the F# compiler consists of location (start and end),
+ error kind and the message (wrapped in a single case discriminated union
+ with constructor SourceError)
+
+ A token in a parsed F# code snippet. Aside from standard tokens reported from
+ the compiler (Token), this also includes Error (wrapping the underlined
+ tokens), Omitted for the special [omit:...] tags and Output for the special [output:...] tag
+
+ Full Usage:
+ mkPageContentMenu html
+
+
+ Parameters:
+
+
+
+ html
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string list * string
+
+
+
+
+
+
+
+
+
+
+
+
+ We process the html to collect the table of content.
+ We can't use the doc.MarkdownDocument because we cannot easily get the generated id values.
+ It is safer to parse the html.
+
+ Regular expression string to match single line and multi-line
+ comments (// and (* *)). Single line comments should have to have
+ a space after them to avoid color as comments URLs and paths. For example
+
+
+ Provides a base implementation for all code formatters.
+
+
+
+
+
+
+ To display the formatted code on your web site, the web page must
+ refer to a stylesheet that defines the formatting for the different
+ CSS classes generated by CSharpFormat:
+ .csharpcode, pre, .rem, .kwrd, .str, .op, .preproc, .alt, .lnum.
+
+ Note that if you have multi-line comments in your source code
+ (like /* ... */), the "line numbers" or "alternate line background"
+ options will generate code that is not strictly HTML 4.01 compliant.
+ The code will still look good with IE5+ or Mozilla 0.8+.
+
+ Register a function that formats (some) values that are produced by the evaluator.
+ The specified function should return 'Some' when it knows how to format a value
+ and it should return formatted
+
+ Creates a dummy fsi object that does not affect the behaviour of F# Interactive
+ (and simply ignores all operations that are done on it). You can use this to
+ e.g. disable registered printers that would open new windows etc.
+
+
+ This type provides three simple methods for calling the literate programming tool.
+ The ConvertMarkdownFile and ConvertScriptFile methods process a single Markdown document
+ and F# script, respectively. The ConvertDirectory method handles an entire directory tree
+ (looking for *.fsx and *.md files).
+
+
+
+ Additional properties of a literate code snippet, embedded in a
+ LiterateParagraph.LiterateCode. The properties specify how should
+ a snippet be evaluated and formatted.
+
+
+ Full Usage:
+ OutputName
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ Specifies the name of the output produced by this snippet
+ Use the (*** define-output:foo ***) command to set this value
+ Other outputs are named cell1, cell2 etc.
+
+
+ Extends MarkdownParagrap using the MarkdownEmbedParagraphs case with
+ additional kinds of paragraphs that can appear in literate F# scripts
+ (such as various special commands to embed output of a snippet etc.)
+
+
+ (*** include-fsi-merged-output ***) - Include output from previous snippet
+ (*** include-fsi-merged-output:foo ***) - Include output from a named snippet
+
+ (*** include-it-raw ***) - Include "it" value from the subsequent snippet here as raw text (Not formatted as fsi)
+ (*** include-it-raw:foo ***) - Include "it" value from a named snippet as raw text (Not formatted as fsi)
+
+ (*** include-fsi-output ***) - Include F# Interactive output from previous snippet
+ (*** include-fsi-output:foo ***) - Include F# Interactive from a named snippet
+
+
+ This type provides three simple methods for calling the literate programming tool.
+ The ConvertMarkdownFile and ConvertScriptFile methods process a single Markdown document
+ and F# script, respectively. The ConvertDirectory method handles an entire directory tree
+ (looking for *.fsx and *.md files).
+
+
+
+ Additional properties of a literate code snippet, embedded in a
+ LiterateParagraph.LiterateCode. The properties specify how should
+ a snippet be evaluated and formatted.
+
+
+
+ Extends MarkdownParagrap using the MarkdownEmbedParagraphs case with
+ additional kinds of paragraphs that can appear in literate F# scripts
+ (such as various special commands to embed output of a snippet etc.)
+
+
+ Format Markdown document and write the result to
+ a specified TextWriter. Parameters specify newline character
+ and a dictionary with link keys defined in the document.
+
+ Provides an extensibility point for adding custom kinds of paragraphs into a document
+ (MarkdownEmbedParagraphs values can be embedded using MarkdownParagraph.EmbedParagraphs)
+
+ Provides an extensibility point for adding custom kinds of spans into a document
+ (MarkdownEmbedSpans values can be embedded using MarkdownSpan.EmbedSpans)
+
+ A paragraph represents a (possibly) multi-line element of a Markdown document.
+ Paragraphs are headings, inline paragraphs, code blocks, lists, quotations, tables and
+ also embedded LaTeX blocks.
+
+ Represents inline formatting inside a paragraph. This can be literal (with text), various
+ formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc.
+
+ Provides an extensibility point for adding custom kinds of paragraphs into a document
+ (MarkdownEmbedParagraphs values can be embedded using MarkdownParagraph.EmbedParagraphs)
+
+ Provides an extensibility point for adding custom kinds of spans into a document
+ (MarkdownEmbedSpans values can be embedded using MarkdownSpan.EmbedSpans)
+
+ A paragraph represents a (possibly) multi-line element of a Markdown document.
+ Paragraphs are headings, inline paragraphs, code blocks, lists, quotations, tables and
+ also embedded LaTeX blocks.
+
+ Represents inline formatting inside a paragraph. This can be literal (with text), various
+ formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc.
+
+ Meta data from files that contains front matter
+ Used to determine upfront which files have front matter so that previous and next substitutes can be discovered.
+
+ A parameter key known to FSharp.Formatting, it is HTML composed from additional frontmatter information.
+ Such as tags and description
+ This can be empty when both properties are not provided for the current page.
+
+ Meta data from files that contains front matter
+ Used to determine upfront which files have front matter so that previous and next substitutes can be discovered.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/sidebyside/sideextensions.ipynb b/sidebyside/sideextensions.ipynb
new file mode 100644
index 000000000..20d838957
--- /dev/null
+++ b/sidebyside/sideextensions.ipynb
@@ -0,0 +1,80 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Example: Using the Markdown Extensions for LaTeX\n",
+ "\n",
+ "\u003cscript id=\"MathJax-script\" async src=\"https://cdn.jsdelivr.net/npm/mathjax@3.0.1/es5/tex-mml-chtml.js\"\u003e\u003c/script\u003e\n",
+ "\n",
+ "To use LaTex extension, you need add javascript\n",
+ "link to [MathJax](http://www.mathjax.org/) in\n",
+ "your template or inside a `_head.html` file.\n",
+ "\n",
+ "```html\n",
+ "\u003cscript id=\"MathJax-script\" async src=\"https://cdn.jsdelivr.net/npm/mathjax@3.0.1/es5/tex-mml-chtml.js\"\u003e\u003c/script\u003e\n",
+ "```\n",
+ "\n",
+ "To use inline LaTex, eclose LaTex code with `$`:\n",
+ "$k_{n+1} = n^2 + k_n^2 - k_{n-1}$. Alternatively,\n",
+ "you can also use `$$`.\n",
+ "\n",
+ "To use block LaTex, start a new parapgraph, with\n",
+ "the first line marked as `$$$` (no close `$$$`):\n",
+ "\n",
+ "\\begin{equation}\n",
+ "A_{m,n} =\n",
+ " \\begin{pmatrix}\n",
+ " a_{1,1} \u0026 a_{1,2} \u0026 \\cdots \u0026 a_{1,n} \\\\\n",
+ " a_{2,1} \u0026 a_{2,2} \u0026 \\cdots \u0026 a_{2,n} \\\\\n",
+ " \\vdots \u0026 \\vdots \u0026 \\ddots \u0026 \\vdots \\\\\n",
+ " a_{m,1} \u0026 a_{m,2} \u0026 \\cdots \u0026 a_{m,n}\n",
+ " \\end{pmatrix}\n",
+ "\\end{equation}\n",
+ "\n",
+ "Use LaTex escape rule:\n",
+ "\n",
+ "* Escape $ in inline mode: $\\$$, $\\$var$\n",
+ "\n",
+ "* Other escapes: $\\\u0026 \\% \\$ \\# \\_ \\{ \\}$\n",
+ "\n",
+ "* Using \u003c or \u003e: $x \u003e 1$, $y \u003c 1$, $x \u003e= 1$,\n",
+ "$y \u003c= 1$, $x = 1$\n",
+ "\n",
+ "* $\u003cp\u003esomething\u003c/p\u003e$\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/sidebyside/sideextensions.md b/sidebyside/sideextensions.md
new file mode 100644
index 000000000..dbbd066bc
--- /dev/null
+++ b/sidebyside/sideextensions.md
@@ -0,0 +1,41 @@
+# Example: Using the Markdown Extensions for LaTeX
+
+
+
+To use LaTex extension, you need add javascript
+link to [MathJax](http://www.mathjax.org/) in
+your template or inside a `_head.html` file.
+
+```html
+
+```
+
+To use inline LaTex, eclose LaTex code with `$`:
+$k_{n+1} = n^2 + k_n^2 - k_{n-1}$. Alternatively,
+you can also use `$$`.
+
+To use block LaTex, start a new parapgraph, with
+the first line marked as `$$$` (no close `$$$`):
+
+\begin{equation}
+A_{m,n} =
+ \begin{pmatrix}
+ a_{1,1} & a_{1,2} & \cdots & a_{1,n} \\
+ a_{2,1} & a_{2,2} & \cdots & a_{2,n} \\
+ \vdots & \vdots & \ddots & \vdots \\
+ a_{m,1} & a_{m,2} & \cdots & a_{m,n}
+ \end{pmatrix}
+\end{equation}
+
+Use LaTex escape rule:
+
+* Escape $ in inline mode: $\$$, $\$var$
+
+* Other escapes: $\& \% \$ \# \_ \{ \}$
+
+* Using < or >: $x > 1$, $y < 1$, $x >= 1$,
+$y <= 1$, $x = 1$
+
+* $
something
$
+
+
diff --git a/sidebyside/sideextensions.tex b/sidebyside/sideextensions.tex
new file mode 100644
index 000000000..3e1aeaa8f
--- /dev/null
+++ b/sidebyside/sideextensions.tex
@@ -0,0 +1,100 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Example: Using the Markdown Extensions for LaTeX}
+
+
+
+
+
+
+To use LaTex extension, you need add javascript
+link to \href{http://www.mathjax.org/}{MathJax} in
+your template or inside a \texttt{\_head.html} file.
+\begin{lstlisting}
+
+
+\end{lstlisting}
+
+
+To use inline LaTex, eclose LaTex code with \texttt{\$}:
+$k_{n+1} = n^2 + k_n^2 - k_{n-1}$. Alternatively,
+you can also use \texttt{\$\$}.
+
+
+To use block LaTex, start a new parapgraph, with
+the first line marked as \texttt{\$\$\$} (no close \texttt{\$\$\$}):
+
+
+\begin{equation}
+A_{m,n} =
+ \begin{pmatrix}
+ a_{1,1} & a_{1,2} & \cdots & a_{1,n} \\
+ a_{2,1} & a_{2,2} & \cdots & a_{2,n} \\
+ \vdots & \vdots & \ddots & \vdots \\
+ a_{m,1} & a_{m,2} & \cdots & a_{m,n}
+ \end{pmatrix}
+\end{equation}
+
+
+
+
+Use LaTex escape rule:
+\begin{itemize}
+\item Escape \$ in inline mode: $\$$, $\$var$
+
+\item Other escapes: $\& \% \$ \# \_ \{ \}$
+
+\item Using < or >: $x > 1$, $y < 1$, $x >= 1$,
+$y <= 1$, $x = 1$
+
+\item $
something
$
+
+\end{itemize}
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/sidebyside/sidemarkdown.fsx b/sidebyside/sidemarkdown.fsx
new file mode 100644
index 000000000..ba0715d57
--- /dev/null
+++ b/sidebyside/sidemarkdown.fsx
@@ -0,0 +1,66 @@
+(**
+# Example: Using Markdown Content
+
+This file demonstrates how to write Markdown document with
+embedded F# snippets that can be transformed into nice HTML
+using the `literate.fsx` script from the [F# Formatting
+package](http://fsprojects.github.io/FSharp.Formatting).
+
+In this case, the document itself is a valid Markdown and
+you can use standard Markdown features to format the text:
+
+* Here is an example of unordered list and...
+
+* Text formatting including **bold** and **emphasis**
+
+For more information, see the [Markdown](http://daringfireball.net/projects/markdown) reference.
+
+## Writing F# code
+
+In standard Markdown, you can include code snippets by
+writing a block indented by four spaces and the code
+snippet will be turned into a `
` element. If you do
+the same using Literate F# tool, the code is turned into
+a nicely formatted F# snippet:
+
+ /// The Hello World of functional languages!
+ let rec factorial x =
+ if x = 0 then 1
+ else x * (factorial (x - 1))
+
+ let f10 = factorial 10
+
+
+## Hiding code
+
+If you want to include some code in the source code,
+but omit it from the output, you can use the `hide`
+command. You can also use `module=...` to specify that
+the snippet should be placed in a separate module
+(e.g. to avoid duplicate definitions).
+
+ [hide, module=Hidden]
+ /// This is a hidden answer
+ let answer = 42
+
+The value will be deffined in the F# code that is
+processed and so you can use it from other (visible)
+code and get correct tool tips:
+
+ let answer = Hidden.answer
+
+## Including other snippets
+
+When writing literate programs as Markdown documents,
+you can also include snippets in other languages.
+These will not be colorized and processed as F#
+code samples:
+
+ [lang=csharp]
+ Console.WriteLine("Hello world!");
+
+This snippet is turned into a `pre` element with the
+`lang` attribute set to `csharp`.
+
+*)
+
diff --git a/sidebyside/sidemarkdown.html b/sidebyside/sidemarkdown.html
new file mode 100644
index 000000000..ede5688c6
--- /dev/null
+++ b/sidebyside/sidemarkdown.html
@@ -0,0 +1,389 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown Content | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This file demonstrates how to write Markdown document with
+embedded F# snippets that can be transformed into nice HTML
+using the literate.fsx script from the F# Formatting
+package.
+
In this case, the document itself is a valid Markdown and
+you can use standard Markdown features to format the text:
In standard Markdown, you can include code snippets by
+writing a block indented by four spaces and the code
+snippet will be turned into a <pre> element. If you do
+the same using Literate F# tool, the code is turned into
+a nicely formatted F# snippet:
+
/// The Hello World of functional languages!
+letrecfactorialx=
+ ifx=0then1
+ elsex*(factorial(x-1))
+
+letf10=factorial10
+
If you want to include some code in the source code,
+but omit it from the output, you can use the hide
+command. You can also use module=... to specify that
+the snippet should be placed in a separate module
+(e.g. to avoid duplicate definitions).
+
The value will be deffined in the F# code that is
+processed and so you can use it from other (visible)
+code and get correct tool tips:
When writing literate programs as Markdown documents,
+you can also include snippets in other languages.
+These will not be colorized and processed as F#
+code samples:
+
Console.WriteLine("Hello world!");
+
+
This snippet is turned into a pre element with the
+lang attribute set to csharp.
+
+
val factorial: x: int -> int The Hello World of functional languages!
+
val x: int
+
val f10: int
+
val answer: int
+
module Hidden
+
+from sidemarkdown
+
val answer: int This is a hidden answer
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/sidebyside/sidemarkdown.ipynb b/sidebyside/sidemarkdown.ipynb
new file mode 100644
index 000000000..5eee4b0fb
--- /dev/null
+++ b/sidebyside/sidemarkdown.ipynb
@@ -0,0 +1,103 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Example: Using Markdown Content\n",
+ "\n",
+ "This file demonstrates how to write Markdown document with\n",
+ "embedded F# snippets that can be transformed into nice HTML\n",
+ "using the `literate.fsx` script from the [F# Formatting\n",
+ "package](http://fsprojects.github.io/FSharp.Formatting).\n",
+ "\n",
+ "In this case, the document itself is a valid Markdown and\n",
+ "you can use standard Markdown features to format the text:\n",
+ "\n",
+ "* Here is an example of unordered list and...\n",
+ "\n",
+ "* Text formatting including **bold** and **emphasis**\n",
+ "\n",
+ "For more information, see the [Markdown](http://daringfireball.net/projects/markdown) reference.\n",
+ "\n",
+ "## Writing F# code\n",
+ "\n",
+ "In standard Markdown, you can include code snippets by\n",
+ "writing a block indented by four spaces and the code\n",
+ "snippet will be turned into a `\u003cpre\u003e` element. If you do\n",
+ "the same using Literate F# tool, the code is turned into\n",
+ "a nicely formatted F# snippet:\n",
+ "\n",
+ " /// The Hello World of functional languages!\n",
+ " let rec factorial x = \n",
+ " if x = 0 then 1 \n",
+ " else x * (factorial (x - 1))\n",
+ "\n",
+ " let f10 = factorial 10\n",
+ "\n",
+ "\n",
+ "## Hiding code\n",
+ "\n",
+ "If you want to include some code in the source code,\n",
+ "but omit it from the output, you can use the `hide`\n",
+ "command. You can also use `module=...` to specify that\n",
+ "the snippet should be placed in a separate module\n",
+ "(e.g. to avoid duplicate definitions).\n",
+ "\n",
+ " [hide, module=Hidden]\n",
+ " /// This is a hidden answer\n",
+ " let answer = 42\n",
+ "\n",
+ "The value will be deffined in the F# code that is\n",
+ "processed and so you can use it from other (visible)\n",
+ "code and get correct tool tips:\n",
+ "\n",
+ " let answer = Hidden.answer\n",
+ "\n",
+ "## Including other snippets\n",
+ "\n",
+ "When writing literate programs as Markdown documents,\n",
+ "you can also include snippets in other languages.\n",
+ "These will not be colorized and processed as F#\n",
+ "code samples:\n",
+ "\n",
+ " [lang=csharp]\n",
+ " Console.WriteLine(\"Hello world!\");\n",
+ "\n",
+ "This snippet is turned into a `pre` element with the\n",
+ "`lang` attribute set to `csharp`.\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/sidebyside/sidemarkdown.md b/sidebyside/sidemarkdown.md
new file mode 100644
index 000000000..51ed3d1a1
--- /dev/null
+++ b/sidebyside/sidemarkdown.md
@@ -0,0 +1,64 @@
+# Example: Using Markdown Content
+
+This file demonstrates how to write Markdown document with
+embedded F# snippets that can be transformed into nice HTML
+using the `literate.fsx` script from the [F# Formatting
+package](http://fsprojects.github.io/FSharp.Formatting).
+
+In this case, the document itself is a valid Markdown and
+you can use standard Markdown features to format the text:
+
+* Here is an example of unordered list and...
+
+* Text formatting including **bold** and **emphasis**
+
+For more information, see the [Markdown](http://daringfireball.net/projects/markdown) reference.
+
+## Writing F# code
+
+In standard Markdown, you can include code snippets by
+writing a block indented by four spaces and the code
+snippet will be turned into a `
` element. If you do
+the same using Literate F# tool, the code is turned into
+a nicely formatted F# snippet:
+
+ /// The Hello World of functional languages!
+ let rec factorial x =
+ if x = 0 then 1
+ else x * (factorial (x - 1))
+
+ let f10 = factorial 10
+
+
+## Hiding code
+
+If you want to include some code in the source code,
+but omit it from the output, you can use the `hide`
+command. You can also use `module=...` to specify that
+the snippet should be placed in a separate module
+(e.g. to avoid duplicate definitions).
+
+ [hide, module=Hidden]
+ /// This is a hidden answer
+ let answer = 42
+
+The value will be deffined in the F# code that is
+processed and so you can use it from other (visible)
+code and get correct tool tips:
+
+ let answer = Hidden.answer
+
+## Including other snippets
+
+When writing literate programs as Markdown documents,
+you can also include snippets in other languages.
+These will not be colorized and processed as F#
+code samples:
+
+ [lang=csharp]
+ Console.WriteLine("Hello world!");
+
+This snippet is turned into a `pre` element with the
+`lang` attribute set to `csharp`.
+
+
diff --git a/sidebyside/sidemarkdown.tex b/sidebyside/sidemarkdown.tex
new file mode 100644
index 000000000..9f84cb555
--- /dev/null
+++ b/sidebyside/sidemarkdown.tex
@@ -0,0 +1,131 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Example: Using Markdown Content}
+
+
+
+This file demonstrates how to write Markdown document with
+embedded F\# snippets that can be transformed into nice HTML
+using the \texttt{literate.fsx} script from the \href{http://fsprojects.github.io/FSharp.Formatting}{F\# Formatting
+package}.
+
+
+In this case, the document itself is a valid Markdown and
+you can use standard Markdown features to format the text:
+\begin{itemize}
+\item Here is an example of unordered list and...
+
+\item Text formatting including \textbf{bold} and \emph{emphasis}
+
+\end{itemize}
+
+
+
+For more information, see the \href{http://daringfireball.net/projects/markdown}{Markdown} reference.
+\subsection*{Writing F\# code}
+
+
+
+In standard Markdown, you can include code snippets by
+writing a block indented by four spaces and the code
+snippet will be turned into a \texttt{
} element. If you do
+the same using Literate F\# tool, the code is turned into
+a nicely formatted F\# snippet:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// The Hello World of functional languages!}
+\kwd{let} \kwd{rec} \lfun{factorial} \lfun{x} \ops{=}
+ \kwd{if} \lfun{x} \ops{=} \num{0} \kwd{then} \num{1}
+ \kwd{else} \lfun{x} \ops{*} {(}\lfun{factorial} {(}\lfun{x} \ops{-} \num{1}{)}{)}
+
+\kwd{let} \id{f10} \ops{=} \lfun{factorial} \num{10}
+
+
+\end{lstlisting}
+
+\subsection*{Hiding code}
+
+
+
+If you want to include some code in the source code,
+but omit it from the output, you can use the \texttt{hide}
+command. You can also use \texttt{module=...} to specify that
+the snippet should be placed in a separate module
+(e.g. to avoid duplicate definitions).
+
+
+The value will be deffined in the F\# code that is
+processed and so you can use it from other (visible)
+code and get correct tool tips:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{answer} \ops{=} \ltyp{Hidden}{.}\id{answer}
+
+
+\end{lstlisting}
+
+\subsection*{Including other snippets}
+
+
+
+When writing literate programs as Markdown documents,
+you can also include snippets in other languages.
+These will not be colorized and processed as F\#
+code samples:
+\begin{lstlisting}
+Console.WriteLine("Hello world!");
+
+\end{lstlisting}
+
+
+This snippet is turned into a \texttt{pre} element with the
+\texttt{lang} attribute set to \texttt{csharp}.
+
+
+\end{document}
\ No newline at end of file
diff --git a/sidebyside/sidescript.fsx b/sidebyside/sidescript.fsx
new file mode 100644
index 000000000..72bfd87a1
--- /dev/null
+++ b/sidebyside/sidescript.fsx
@@ -0,0 +1,68 @@
+(**
+# Example: Using Literate Script Content
+
+This file demonstrates how to write literate F# script
+files (`*.fsx`) that can be transformed into nice HTML
+using the `literate.fsx` script from the [F# Formatting
+package](http://fsprojects.github.io/FSharp.Formatting).
+
+As you can see, a comment starting with double asterisk
+is treated as part of the document and is transformed
+using Markdown, which means that you can use:
+
+* Unordered or ordered lists
+
+* Text formatting including **bold** and **emphasis**
+
+And numerous other [Markdown](http://daringfireball.net/projects/markdown) features.
+
+## Writing F# code
+
+Code that is not inside comment will be formatted as
+a sample snippet.
+
+*)
+/// The Hello World of functional languages!
+let rec factorial x =
+ if x = 0 then 1 else x * (factorial (x - 1))
+
+let f10 = factorial 10
+(**
+## Hiding code
+
+If you want to include some code in the source code,
+but omit it from the output, you can use the `hide`
+command.
+
+The value will be defined in the F# code and so you
+can use it from other (visible) code and get correct
+tool tips:
+
+*)
+let answer = hidden
+(**
+## Moving code around
+
+Sometimes, it is useful to first explain some code that
+has to be located at the end of the snippet (perhaps
+because it uses some definitions discussed in the middle).
+This can be done using `include` and `define` commands.
+
+The following snippet gets correct tool tips, even though
+it uses `laterFunction`:
+
+*)
+let sample = laterFunction () |> printfn "Got: %s"
+(**
+Then we can explain how `laterFunction` is defined:
+
+*)
+let laterFunction () = "Not very difficult, is it?"
+(**
+This example covers pretty much all features that are
+currently implemented in `literate.fsx`, but feel free
+to [fork the project on GitHub](https://github.com/fsprojects/FSharp.Formatting) and add more
+features or report bugs!
+
+*)
+
diff --git a/sidebyside/sidescript.html b/sidebyside/sidescript.html
new file mode 100644
index 000000000..3c45c06ed
--- /dev/null
+++ b/sidebyside/sidescript.html
@@ -0,0 +1,391 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate Script | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This file demonstrates how to write literate F# script
+files (*.fsx) that can be transformed into nice HTML
+using the literate.fsx script from the F# Formatting
+package.
+
As you can see, a comment starting with double asterisk
+is treated as part of the document and is transformed
+using Markdown, which means that you can use:
Sometimes, it is useful to first explain some code that
+has to be located at the end of the snippet (perhaps
+because it uses some definitions discussed in the middle).
+This can be done using include and define commands.
+
The following snippet gets correct tool tips, even though
+it uses laterFunction:
+
letsample=laterFunction()|>printfn"Got: %s"
+
+
Then we can explain how laterFunction is defined:
+
letlaterFunction()="Not very difficult, is it?"
+
+
This example covers pretty much all features that are
+currently implemented in literate.fsx, but feel free
+to fork the project on GitHub and add more
+features or report bugs!
+
+
val factorial: x: int -> int The Hello World of functional languages!
+
val x: int
+
val f10: int
+
val hidden: int This is a hidden answer
+
val answer: int
+
val laterFunction: unit -> string
+
val sample: unit
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/sidebyside/sidescript.ipynb b/sidebyside/sidescript.ipynb
new file mode 100644
index 000000000..9237617c7
--- /dev/null
+++ b/sidebyside/sidescript.ipynb
@@ -0,0 +1,189 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Example: Using Literate Script Content\n",
+ "\n",
+ "This file demonstrates how to write literate F# script\n",
+ "files (`*.fsx`) that can be transformed into nice HTML\n",
+ "using the `literate.fsx` script from the [F# Formatting\n",
+ "package](http://fsprojects.github.io/FSharp.Formatting).\n",
+ "\n",
+ "As you can see, a comment starting with double asterisk\n",
+ "is treated as part of the document and is transformed\n",
+ "using Markdown, which means that you can use:\n",
+ "\n",
+ "* Unordered or ordered lists\n",
+ "\n",
+ "* Text formatting including **bold** and **emphasis**\n",
+ "\n",
+ "And numerous other [Markdown](http://daringfireball.net/projects/markdown) features.\n",
+ "\n",
+ "## Writing F# code\n",
+ "\n",
+ "Code that is not inside comment will be formatted as\n",
+ "a sample snippet.\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// The Hello World of functional languages!\n",
+ "let rec factorial x =\n",
+ " if x = 0 then 1 else x * (factorial (x - 1))\n",
+ "\n",
+ "let f10 = factorial 10\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "## Hiding code\n",
+ "\n",
+ "If you want to include some code in the source code,\n",
+ "but omit it from the output, you can use the `hide`\n",
+ "command.\n",
+ "\n",
+ "The value will be defined in the F# code and so you\n",
+ "can use it from other (visible) code and get correct\n",
+ "tool tips:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let answer = hidden\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "## Moving code around\n",
+ "\n",
+ "Sometimes, it is useful to first explain some code that\n",
+ "has to be located at the end of the snippet (perhaps\n",
+ "because it uses some definitions discussed in the middle).\n",
+ "This can be done using `include` and `define` commands.\n",
+ "\n",
+ "The following snippet gets correct tool tips, even though\n",
+ "it uses `laterFunction`:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let sample = laterFunction () |\u003e printfn \"Got: %s\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "Then we can explain how `laterFunction` is defined:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let laterFunction () = \"Not very difficult, is it?\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "This example covers pretty much all features that are\n",
+ "currently implemented in `literate.fsx`, but feel free\n",
+ "to [fork the project on GitHub](https://github.com/fsprojects/FSharp.Formatting) and add more\n",
+ "features or report bugs!\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/sidebyside/sidescript.md b/sidebyside/sidescript.md
new file mode 100644
index 000000000..4e16da661
--- /dev/null
+++ b/sidebyside/sidescript.md
@@ -0,0 +1,70 @@
+# Example: Using Literate Script Content
+
+This file demonstrates how to write literate F# script
+files (`*.fsx`) that can be transformed into nice HTML
+using the `literate.fsx` script from the [F# Formatting
+package](http://fsprojects.github.io/FSharp.Formatting).
+
+As you can see, a comment starting with double asterisk
+is treated as part of the document and is transformed
+using Markdown, which means that you can use:
+
+* Unordered or ordered lists
+
+* Text formatting including **bold** and **emphasis**
+
+And numerous other [Markdown](http://daringfireball.net/projects/markdown) features.
+
+## Writing F# code
+
+Code that is not inside comment will be formatted as
+a sample snippet.
+
+```fsharp
+/// The Hello World of functional languages!
+let rec factorial x =
+ if x = 0 then 1 else x * (factorial (x - 1))
+
+let f10 = factorial 10
+```
+
+## Hiding code
+
+If you want to include some code in the source code,
+but omit it from the output, you can use the `hide`
+command.
+
+The value will be defined in the F# code and so you
+can use it from other (visible) code and get correct
+tool tips:
+
+```fsharp
+let answer = hidden
+```
+
+## Moving code around
+
+Sometimes, it is useful to first explain some code that
+has to be located at the end of the snippet (perhaps
+because it uses some definitions discussed in the middle).
+This can be done using `include` and `define` commands.
+
+The following snippet gets correct tool tips, even though
+it uses `laterFunction`:
+
+```fsharp
+let sample = laterFunction () |> printfn "Got: %s"
+```
+
+Then we can explain how `laterFunction` is defined:
+
+```fsharp
+let laterFunction () = "Not very difficult, is it?"
+```
+
+This example covers pretty much all features that are
+currently implemented in `literate.fsx`, but feel free
+to [fork the project on GitHub](https://github.com/fsprojects/FSharp.Formatting) and add more
+features or report bugs!
+
+
diff --git a/sidebyside/sidescript.tex b/sidebyside/sidescript.tex
new file mode 100644
index 000000000..905836042
--- /dev/null
+++ b/sidebyside/sidescript.tex
@@ -0,0 +1,143 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Example: Using Literate Script Content}
+
+
+
+This file demonstrates how to write literate F\# script
+files (\texttt{*.fsx}) that can be transformed into nice HTML
+using the \texttt{literate.fsx} script from the \href{http://fsprojects.github.io/FSharp.Formatting}{F\# Formatting
+package}.
+
+
+As you can see, a comment starting with double asterisk
+is treated as part of the document and is transformed
+using Markdown, which means that you can use:
+\begin{itemize}
+\item Unordered or ordered lists
+
+\item Text formatting including \textbf{bold} and \emph{emphasis}
+
+\end{itemize}
+
+
+
+And numerous other \href{http://daringfireball.net/projects/markdown}{Markdown} features.
+\subsection*{Writing F\# code}
+
+
+
+Code that is not inside comment will be formatted as
+a sample snippet.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// The Hello World of functional languages!}
+\kwd{let} \kwd{rec} \lfun{factorial} \lfun{x} \ops{=}
+ \kwd{if} \lfun{x} \ops{=} \num{0} \kwd{then} \num{1} \kwd{else} \lfun{x} \ops{*} {(}\lfun{factorial} {(}\lfun{x} \ops{-} \num{1}{)}{)}
+
+\kwd{let} \id{f10} \ops{=} \lfun{factorial} \num{10}
+
+\end{lstlisting}
+
+\subsection*{Hiding code}
+
+
+
+If you want to include some code in the source code,
+but omit it from the output, you can use the \texttt{hide}
+command.
+
+
+The value will be defined in the F\# code and so you
+can use it from other (visible) code and get correct
+tool tips:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{answer} \ops{=} \id{hidden}
+
+\end{lstlisting}
+
+\subsection*{Moving code around}
+
+
+
+Sometimes, it is useful to first explain some code that
+has to be located at the end of the snippet (perhaps
+because it uses some definitions discussed in the middle).
+This can be done using \texttt{include} and \texttt{define} commands.
+
+
+The following snippet gets correct tool tips, even though
+it uses \texttt{laterFunction}:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{sample} \ops{=} \lfun{laterFunction} {(}{)} \ops{|>} \lfun{printfn} \str{"Got: }\lprf{\%s}\str{"}
+
+\end{lstlisting}
+
+
+
+Then we can explain how \texttt{laterFunction} is defined:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \lfun{laterFunction} {(}{)} \ops{=} \str{"Not very difficult, is it?"}
+
+\end{lstlisting}
+
+
+
+This example covers pretty much all features that are
+currently implemented in \texttt{literate.fsx}, but feel free
+to \href{https://github.com/fsprojects/FSharp.Formatting}{fork the project on GitHub} and add more
+features or report bugs!
+
+
+\end{document}
\ No newline at end of file
diff --git a/styling.fsx b/styling.fsx
new file mode 100644
index 000000000..0beafca2a
--- /dev/null
+++ b/styling.fsx
@@ -0,0 +1,212 @@
+(**
+# Customization and Styling
+
+When using `fsdocs`, there are six levels of extra content development and styling.
+
+0 Don't do any styling or documentation customization and simply write content. This is by far the simplest option to
+maintain.
+
+
+1 Add content such as an `docs/index.md` to customize the front-page content for your generated docs.
+You can also add content such as `docs/reference/fslib.md` to give a bespoke landing page
+for one of your namespaces, e.g. here assumed to be `namespace FsLib`. This will override any
+generated content.
+
+
+2 Customize via Styling Parameters
+
+
+3 Customize via CSS
+
+
+4 Customize via a new template
+
+
+5 Customize by generating your own site using your own code
+
+
+By default `fsdocs` does no styling customization and uses the following defaults. These are the settings used to build
+this site.
+
+* Uses the default template
+in [docs/_template.html](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/_template.html)
+
+
+* Uses the default styles
+in [docs/content/fsdocs-default.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).
+
+
+* Uses no custom styles
+in [docs/content/fsdocs-custom.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).
+
+
+* Uses no styling parameters except those extracted from the project files.
+
+
+For your project, you don't need any of these files. However you can add them if you wish, though if
+you adjust them there is no guarantee that your template will continue to work with future versions of F# Formatting.
+
+## Customizing via Styling Parameters
+
+The following [content parameters](content.html) are particularly related to visual styling:
+
+Substitution name | Value (if not overriden by --parameters)
+:--- | :---
+`fsdocs-authors` | ``
+`fsdocs-license-link` | ``
+`fsdocs-logo-src` | ``
+`fsdocs-favicon-src` | ``
+`fsdocs-logo-link` | ``
+`fsdocs-release-notes-link` | `` else `/blob/master/RELEASE_NOTES.md`
+`fsdocs-repository-link` | ``
+`fsdocs-theme` | ``, must currently be `default`
+
+
+These basic entry-level styling parameters can be set in the project file or `Directory.Build.props`.
+For example:
+
+```xml
+
+
+ https://github.com/foo/bar/blob/master/License.txt
+ https://foo.github.io/bar/
+ https://github.com/foo/bar/
+ https://fsharp.org
+ img/logo.png
+ img/favicon.ico
+ https://github.com/foo/bar/blob/master/License.txt
+ https://github.com/foo/bar/blob/master/release-notes.md
+ true
+ default
+
+```
+
+As an example, here is [a page with alternative styling](templates/leftside/styling.html).
+
+## Customizing via CSS
+
+You can start styling by creating a file `docs/content/fsdocs-theme.css` and adding entries to it.
+It is loaded by the standard template.
+
+### CSS variables
+
+The default template is heavily based
+on [CSS variables](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties). These can easily be
+override to customize the look and feel of the default theme.
+A full list of the overrideable variables can be
+found [here](https://github.com/fsprojects/FSharp.Formatting/blob/main/docs/content/fsdocs-default.css).
+
+```css
+:root {
+ --text-color: red;
+}
+
+[data-theme=dark] {
+ --text-color: darkred;
+}
+```
+
+Please be aware that the `dark` mode in the default theme is using the same variables.
+When you override a variable, it will also be used in `dark` mode unless redefined in a `[data-theme=dark]` CSS query.
+
+### CSS classes
+
+The API documentation uses a set of fixed CSS classes:
+
+CSS class | Corresponding Content
+:--- | :---
+`.fsdocs-tip` | generated tooltips
+`.fsdocs-xmldoc` | generated xmldoc sections
+`.fsdocs-member-list` | generated member lists (tables)
+`.fsdocs-member-usage` | usage in generated member lists
+`.fsdocs-member-tooltip` | tooltips in generated member lists
+`.fsdocs-member-xmldoc` | documentation in generated member lists
+`.fsdocs-entity-list` | generated entity lists
+`.fsdocs-entity-name` | generated entity lists
+`.fsdocs-entity-xmldoc` | documentation in generated entity lists
+`.fsdocs-exception-list` | generated exception lists
+`.fsdocs-summary` | the 'summary' section of an XML doc
+`.fsdocs-remarks` | the 'remarks' section of an XML doc
+`.fsdocs-params` | the 'parameters' section of an XML doc
+`.fsdocs-param` | a 'parameter' section of an XML doc
+`.fsdocs-param-name` | a 'parameter' name of an XML doc
+`.fsdocs-returns` | the 'returns' section of an XML doc
+`.fsdocs-example` | the 'example' section of an XML doc
+`.fsdocs-note` | the 'notes' section of an XML doc
+`.fsdocs-para` | a paragraph of an XML doc
+
+
+Some generated elements are given specific HTML ids:
+
+HTML element selector | Content
+:--- | :---
+`header` | The navigation-bar
+`#fsdocs-main-menu` | The main menu on the left side
+`#content` | The generated content
+`#fsdocs-page-menu` | The sub menu on the right side
+`dialog` | The search dialog
+`dialog input[type=search]` | The search box
+`#fsdocs-logo` | The logo
+
+
+If you write a new theme by CSS styling please contribute it back to FSharp.Formatting.
+
+## Customizing via a new template
+
+You can do advanced styling by creating a new template. Add a file `docs/_template.html`, likely starting
+with the existing default template.
+
+> NOTE: To enable hot reload during development with `fsdocs watch` in a custom `_template.html` file,
+make sure to add the single line `{{fsdocs-watch-script}}` to your `` tag.
+NOTE: There is no guarantee that your template will continue to work with future versions of F# Formatting.
+If you do develop a good template please consider contributing it back to F# Formatting.
+>
+
+## Customizing menu items by template
+
+You can add advanced styling to the sidebar generated menu items by creating a new template for it.
+`fsdoc` will look for menu templates in the `--input` folder which defaults to the docs folder.
+
+To customize the generated menu-item headers, use file `_menu_template.html` with starting template:
+
+```html
+
+ {{fsdocs-menu-header-content}}
+
+{{fsdocs-menu-items}}
+```
+
+Similarly, to customize the individual menu item list, use file `_menu-item_template.html` with starting template:
+
+```html
+
+```
+
+Do note that files need to be added prior running or won't be generated.
+In case you want to get a unique identifier for a header or menu item, you can use `{{fsdocs-menu-header-id}}`
+and `{{fsdocs-menu-item-id}}`, respectively.
+
+## Injecting additional html into the default template
+
+Occasionally, you may find the need to make small customizations to the default template, such as adding a Google
+Analytics snippet or including additional style or script tags. To address this scenario, you can create two
+files: `_head.html` and/or `_body.html`.
+
+The content within these files will serve as replacements for the `{{fsdocs-head-extra}}` and `{{fsdocs-body-extra}}`
+placeholders, which are utilized in the default template.
+
+## Customizing by generating your own site using your own code
+
+The `FSharp.Formatting.ApiDocs` namespace includes a `GenerateModel` that captures
+the results of documentation preparation in `ApiDocsModel` and allows you to
+generate your own site using your own code.
+
+> NOTE: The ApiDocsModel API is undergoing change and improvement and there is no guarantee that your bespoke site
+generation will continue to work
+with future versions of F# Formatting.
+NOTE: The `ApiDocsModel` currently includes some generated HTML with some specific style tags.
+In the long term these may be removed from the design of that component.
+>
+
+*)
+
diff --git a/styling.html b/styling.html
new file mode 100644
index 000000000..6163ce14b
--- /dev/null
+++ b/styling.html
@@ -0,0 +1,653 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Customization and Styling
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
When using fsdocs, there are six levels of extra content development and styling.
+
+
+
Don't do any styling or documentation customization and simply write content. This is by far the simplest option to
+maintain.
+
+
+
Add content such as an docs/index.md to customize the front-page content for your generated docs.
+You can also add content such as docs/reference/fslib.md to give a bespoke landing page
+for one of your namespaces, e.g. here assumed to be namespace FsLib. This will override any
+generated content.
+
+
Customize via Styling Parameters
+
Customize via CSS
+
Customize via a new template
+
Customize by generating your own site using your own code
+
+
By default fsdocs does no styling customization and uses the following defaults. These are the settings used to build
+this site.
Uses no styling parameters except those extracted from the project files.
+
+
For your project, you don't need any of these files. However you can add them if you wish, though if
+you adjust them there is no guarantee that your template will continue to work with future versions of F# Formatting.
The default template is heavily based
+on CSS variables. These can easily be
+override to customize the look and feel of the default theme.
+A full list of the overrideable variables can be
+found here.
Please be aware that the dark mode in the default theme is using the same variables.
+When you override a variable, it will also be used in dark mode unless redefined in a [data-theme=dark] CSS query.
You can do advanced styling by creating a new template. Add a file docs/_template.html, likely starting
+with the existing default template.
+
+
NOTE: To enable hot reload during development with fsdocs watch in a custom _template.html file,
+make sure to add the single line {{fsdocs-watch-script}} to your <head> tag.
+NOTE: There is no guarantee that your template will continue to work with future versions of F# Formatting.
+If you do develop a good template please consider contributing it back to F# Formatting.
You can add advanced styling to the sidebar generated menu items by creating a new template for it.
+fsdoc will look for menu templates in the --input folder which defaults to the docs folder.
+
To customize the generated menu-item headers, use file _menu_template.html with starting template:
Do note that files need to be added prior running or won't be generated.
+In case you want to get a unique identifier for a header or menu item, you can use {{fsdocs-menu-header-id}}
+and {{fsdocs-menu-item-id}}, respectively.
Occasionally, you may find the need to make small customizations to the default template, such as adding a Google
+Analytics snippet or including additional style or script tags. To address this scenario, you can create two
+files: _head.html and/or _body.html.
+
The content within these files will serve as replacements for the {{fsdocs-head-extra}} and {{fsdocs-body-extra}}
+placeholders, which are utilized in the default template.
The FSharp.Formatting.ApiDocs namespace includes a GenerateModel that captures
+the results of documentation preparation in ApiDocsModel and allows you to
+generate your own site using your own code.
+
+
NOTE: The ApiDocsModel API is undergoing change and improvement and there is no guarantee that your bespoke site
+generation will continue to work
+with future versions of F# Formatting.
+NOTE: The ApiDocsModel currently includes some generated HTML with some specific style tags.
+In the long term these may be removed from the design of that component.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/styling.ipynb b/styling.ipynb
new file mode 100644
index 000000000..69a17c579
--- /dev/null
+++ b/styling.ipynb
@@ -0,0 +1,249 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Customization and Styling\n",
+ "\n",
+ "When using `fsdocs`, there are six levels of extra content development and styling.\n",
+ "\n",
+ "0 Don\u0027t do any styling or documentation customization and simply write content. This is by far the simplest option to\n",
+ "maintain.\n",
+ " \n",
+ "\n",
+ "1 Add content such as an `docs/index.md` to customize the front-page content for your generated docs.\n",
+ "You can also add content such as `docs/reference/fslib.md` to give a bespoke landing page\n",
+ "for one of your namespaces, e.g. here assumed to be `namespace FsLib`. This will override any\n",
+ "generated content.\n",
+ " \n",
+ "\n",
+ "2 Customize via Styling Parameters\n",
+ " \n",
+ "\n",
+ "3 Customize via CSS\n",
+ " \n",
+ "\n",
+ "4 Customize via a new template\n",
+ " \n",
+ "\n",
+ "5 Customize by generating your own site using your own code\n",
+ " \n",
+ "\n",
+ "By default `fsdocs` does no styling customization and uses the following defaults. These are the settings used to build\n",
+ "this site.\n",
+ "\n",
+ "* Uses the default template\n",
+ "in [docs/_template.html](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/_template.html)\n",
+ " \n",
+ "\n",
+ "* Uses the default styles\n",
+ "in [docs/content/fsdocs-default.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).\n",
+ " \n",
+ "\n",
+ "* Uses no custom styles\n",
+ "in [docs/content/fsdocs-custom.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).\n",
+ " \n",
+ "\n",
+ "* Uses no styling parameters except those extracted from the project files.\n",
+ " \n",
+ "\n",
+ "For your project, you don\u0027t need any of these files. However you can add them if you wish, though if\n",
+ "you adjust them there is no guarantee that your template will continue to work with future versions of F# Formatting.\n",
+ "\n",
+ "## Customizing via Styling Parameters\n",
+ "\n",
+ "The following [content parameters](content.html) are particularly related to visual styling:\n",
+ "\n",
+ "Substitution name | Value (if not overriden by --parameters)\n",
+ ":--- | :---\n",
+ "`fsdocs-authors` | `\u003cAuthors\u003e`\n",
+ "`fsdocs-license-link` | `\u003cFsDocsLicenseLink\u003e`\n",
+ "`fsdocs-logo-src` | `\u003cFsDocsLogoSource\u003e`\n",
+ "`fsdocs-favicon-src` | `\u003cFsDocsFaviconSource\u003e`\n",
+ "`fsdocs-logo-link` | `\u003cFsDocsLogoLink\u003e`\n",
+ "`fsdocs-release-notes-link` | `\u003cFsDocsReleaseNotesLink\u003e` else `\u003cPackageProjectUrl\u003e/blob/master/RELEASE_NOTES.md`\n",
+ "`fsdocs-repository-link` | `\u003cRepositoryUrl\u003e`\n",
+ "`fsdocs-theme` | `\u003cFsDocsTheme\u003e`, must currently be `default`\n",
+ "\n",
+ "\n",
+ "These basic entry-level styling parameters can be set in the project file or `Directory.Build.props`.\n",
+ "For example:\n",
+ "\n",
+ "```xml\n",
+ "\u003cPropertyGroup\u003e\n",
+ " \u003c!-- Example ultra-simple styling and generation settings for FsDocs default template--\u003e\n",
+ " \u003cPackageLicenseUrl\u003ehttps://github.com/foo/bar/blob/master/License.txt\u003c/PackageLicenseUrl\u003e\n",
+ " \u003cPackageProjectUrl\u003ehttps://foo.github.io/bar/\u003c/PackageProjectUrl\u003e\n",
+ " \u003cRepositoryUrl\u003ehttps://github.com/foo/bar/\u003c/RepositoryUrl\u003e\n",
+ " \u003cFsDocsLogoLink\u003ehttps://fsharp.org\u003c/FsDocsLogoLink\u003e\n",
+ " \u003cFsDocsLogoSource\u003eimg/logo.png\u003c/FsDocsLogoSource\u003e\n",
+ " \u003cFsDocsFaviconSource\u003eimg/favicon.ico\u003c/FsDocsFaviconSource\u003e\n",
+ " \u003cFsDocsLicenseLink\u003ehttps://github.com/foo/bar/blob/master/License.txt\u003c/FsDocsLicenseLink\u003e\n",
+ " \u003cFsDocsReleaseNotesLink\u003ehttps://github.com/foo/bar/blob/master/release-notes.md\u003c/FsDocsReleaseNotesLink\u003e\n",
+ " \u003cFsDocsWarnOnMissingDocs\u003etrue\u003c/FsDocsWarnOnMissingDocs\u003e\n",
+ " \u003cFsDocsTheme\u003edefault\u003c/FsDocsTheme\u003e\n",
+ "\u003c/PropertyGroup\u003e\n",
+ "```\n",
+ "\n",
+ "As an example, here is [a page with alternative styling](templates/leftside/styling.html).\n",
+ "\n",
+ "## Customizing via CSS\n",
+ "\n",
+ "You can start styling by creating a file `docs/content/fsdocs-theme.css` and adding entries to it.\n",
+ "It is loaded by the standard template.\n",
+ "\n",
+ "### CSS variables\n",
+ "\n",
+ "The default template is heavily based\n",
+ "on [CSS variables](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties). These can easily be\n",
+ "override to customize the look and feel of the default theme.\n",
+ "A full list of the overrideable variables can be\n",
+ "found [here](https://github.com/fsprojects/FSharp.Formatting/blob/main/docs/content/fsdocs-default.css).\n",
+ "\n",
+ "```css\n",
+ ":root {\n",
+ " --text-color: red;\n",
+ "}\n",
+ "\n",
+ "[data-theme=dark] {\n",
+ " --text-color: darkred;\n",
+ "}\n",
+ "```\n",
+ "\n",
+ "Please be aware that the `dark` mode in the default theme is using the same variables.\n",
+ "When you override a variable, it will also be used in `dark` mode unless redefined in a `[data-theme=dark]` CSS query.\n",
+ "\n",
+ "### CSS classes\n",
+ "\n",
+ "The API documentation uses a set of fixed CSS classes:\n",
+ "\n",
+ "CSS class | Corresponding Content\n",
+ ":--- | :---\n",
+ "`.fsdocs-tip` | generated tooltips\n",
+ "`.fsdocs-xmldoc` | generated xmldoc sections\n",
+ "`.fsdocs-member-list` | generated member lists (tables)\n",
+ "`.fsdocs-member-usage` | usage in generated member lists\n",
+ "`.fsdocs-member-tooltip` | tooltips in generated member lists\n",
+ "`.fsdocs-member-xmldoc` | documentation in generated member lists\n",
+ "`.fsdocs-entity-list` | generated entity lists\n",
+ "`.fsdocs-entity-name` | generated entity lists\n",
+ "`.fsdocs-entity-xmldoc` | documentation in generated entity lists\n",
+ "`.fsdocs-exception-list` | generated exception lists\n",
+ "`.fsdocs-summary` | the \u0027summary\u0027 section of an XML doc\n",
+ "`.fsdocs-remarks` | the \u0027remarks\u0027 section of an XML doc\n",
+ "`.fsdocs-params` | the \u0027parameters\u0027 section of an XML doc\n",
+ "`.fsdocs-param` | a \u0027parameter\u0027 section of an XML doc\n",
+ "`.fsdocs-param-name` | a \u0027parameter\u0027 name of an XML doc\n",
+ "`.fsdocs-returns` | the \u0027returns\u0027 section of an XML doc\n",
+ "`.fsdocs-example` | the \u0027example\u0027 section of an XML doc\n",
+ "`.fsdocs-note` | the \u0027notes\u0027 section of an XML doc\n",
+ "`.fsdocs-para` | a paragraph of an XML doc\n",
+ "\n",
+ "\n",
+ "Some generated elements are given specific HTML ids:\n",
+ "\n",
+ "HTML element selector | Content\n",
+ ":--- | :---\n",
+ "`header` | The navigation-bar\n",
+ "`#fsdocs-main-menu` | The main menu on the left side\n",
+ "`#content` | The generated content\n",
+ "`#fsdocs-page-menu` | The sub menu on the right side\n",
+ "`dialog` | The search dialog\n",
+ "`dialog input[type=search]` | The search box\n",
+ "`#fsdocs-logo` | The logo\n",
+ "\n",
+ "\n",
+ "If you write a new theme by CSS styling please contribute it back to FSharp.Formatting.\n",
+ "\n",
+ "## Customizing via a new template\n",
+ "\n",
+ "You can do advanced styling by creating a new template. Add a file `docs/_template.html`, likely starting\n",
+ "with the existing default template.\n",
+ "\n",
+ "\u003e NOTE: To enable hot reload during development with `fsdocs watch` in a custom `_template.html` file,\n",
+ "make sure to add the single line `{{fsdocs-watch-script}}` to your `\u003chead\u003e` tag.\n",
+ "NOTE: There is no guarantee that your template will continue to work with future versions of F# Formatting.\n",
+ "If you do develop a good template please consider contributing it back to F# Formatting.\n",
+ "\u003e \n",
+ "\n",
+ "## Customizing menu items by template\n",
+ "\n",
+ "You can add advanced styling to the sidebar generated menu items by creating a new template for it.\n",
+ "`fsdoc` will look for menu templates in the `--input` folder which defaults to the docs folder.\n",
+ "\n",
+ "To customize the generated menu-item headers, use file `_menu_template.html` with starting template:\n",
+ "\n",
+ "```html\n",
+ "\u003cli class=\"nav-header\"\u003e\n",
+ " {{fsdocs-menu-header-content}}\n",
+ "\u003c/li\u003e\n",
+ "{{fsdocs-menu-items}}\n",
+ "```\n",
+ "\n",
+ "Similarly, to customize the individual menu item list, use file `_menu-item_template.html` with starting template:\n",
+ "\n",
+ "```html\n",
+ "\u003cli class=\"nav-item\"\u003e\u003ca href=\"{{fsdocs-menu-item-link}}\" class=\"nav-link\"\u003e{{fsdocs-menu-item-content}}\u003c/a\u003e\u003c/li\u003e\n",
+ "```\n",
+ "\n",
+ "Do note that files need to be added prior running or won\u0027t be generated.\n",
+ "In case you want to get a unique identifier for a header or menu item, you can use `{{fsdocs-menu-header-id}}`\n",
+ "and `{{fsdocs-menu-item-id}}`, respectively.\n",
+ "\n",
+ "## Injecting additional html into the default template\n",
+ "\n",
+ "Occasionally, you may find the need to make small customizations to the default template, such as adding a Google\n",
+ "Analytics snippet or including additional style or script tags. To address this scenario, you can create two\n",
+ "files: `_head.html` and/or `_body.html`.\n",
+ "\n",
+ "The content within these files will serve as replacements for the `{{fsdocs-head-extra}}` and `{{fsdocs-body-extra}}`\n",
+ "placeholders, which are utilized in the default template.\n",
+ "\n",
+ "## Customizing by generating your own site using your own code\n",
+ "\n",
+ "The `FSharp.Formatting.ApiDocs` namespace includes a `GenerateModel` that captures\n",
+ "the results of documentation preparation in `ApiDocsModel` and allows you to\n",
+ "generate your own site using your own code.\n",
+ "\n",
+ "\u003e NOTE: The ApiDocsModel API is undergoing change and improvement and there is no guarantee that your bespoke site\n",
+ "generation will continue to work\n",
+ "with future versions of F# Formatting.\n",
+ "NOTE: The `ApiDocsModel` currently includes some generated HTML with some specific style tags.\n",
+ "In the long term these may be removed from the design of that component.\n",
+ "\u003e \n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/styling.md b/styling.md
new file mode 100644
index 000000000..d4cebcdaa
--- /dev/null
+++ b/styling.md
@@ -0,0 +1,210 @@
+# Customization and Styling
+
+When using `fsdocs`, there are six levels of extra content development and styling.
+
+0 Don't do any styling or documentation customization and simply write content. This is by far the simplest option to
+maintain.
+
+
+1 Add content such as an `docs/index.md` to customize the front-page content for your generated docs.
+You can also add content such as `docs/reference/fslib.md` to give a bespoke landing page
+for one of your namespaces, e.g. here assumed to be `namespace FsLib`. This will override any
+generated content.
+
+
+2 Customize via Styling Parameters
+
+
+3 Customize via CSS
+
+
+4 Customize via a new template
+
+
+5 Customize by generating your own site using your own code
+
+
+By default `fsdocs` does no styling customization and uses the following defaults. These are the settings used to build
+this site.
+
+* Uses the default template
+in [docs/_template.html](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/_template.html)
+
+
+* Uses the default styles
+in [docs/content/fsdocs-default.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).
+
+
+* Uses no custom styles
+in [docs/content/fsdocs-custom.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).
+
+
+* Uses no styling parameters except those extracted from the project files.
+
+
+For your project, you don't need any of these files. However you can add them if you wish, though if
+you adjust them there is no guarantee that your template will continue to work with future versions of F# Formatting.
+
+## Customizing via Styling Parameters
+
+The following [content parameters](content.html) are particularly related to visual styling:
+
+Substitution name | Value (if not overriden by --parameters)
+:--- | :---
+`fsdocs-authors` | ``
+`fsdocs-license-link` | ``
+`fsdocs-logo-src` | ``
+`fsdocs-favicon-src` | ``
+`fsdocs-logo-link` | ``
+`fsdocs-release-notes-link` | `` else `/blob/master/RELEASE_NOTES.md`
+`fsdocs-repository-link` | ``
+`fsdocs-theme` | ``, must currently be `default`
+
+
+These basic entry-level styling parameters can be set in the project file or `Directory.Build.props`.
+For example:
+
+```xml
+
+
+ https://github.com/foo/bar/blob/master/License.txt
+ https://foo.github.io/bar/
+ https://github.com/foo/bar/
+ https://fsharp.org
+ img/logo.png
+ img/favicon.ico
+ https://github.com/foo/bar/blob/master/License.txt
+ https://github.com/foo/bar/blob/master/release-notes.md
+ true
+ default
+
+```
+
+As an example, here is [a page with alternative styling](templates/leftside/styling.html).
+
+## Customizing via CSS
+
+You can start styling by creating a file `docs/content/fsdocs-theme.css` and adding entries to it.
+It is loaded by the standard template.
+
+### CSS variables
+
+The default template is heavily based
+on [CSS variables](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties). These can easily be
+override to customize the look and feel of the default theme.
+A full list of the overrideable variables can be
+found [here](https://github.com/fsprojects/FSharp.Formatting/blob/main/docs/content/fsdocs-default.css).
+
+```css
+:root {
+ --text-color: red;
+}
+
+[data-theme=dark] {
+ --text-color: darkred;
+}
+```
+
+Please be aware that the `dark` mode in the default theme is using the same variables.
+When you override a variable, it will also be used in `dark` mode unless redefined in a `[data-theme=dark]` CSS query.
+
+### CSS classes
+
+The API documentation uses a set of fixed CSS classes:
+
+CSS class | Corresponding Content
+:--- | :---
+`.fsdocs-tip` | generated tooltips
+`.fsdocs-xmldoc` | generated xmldoc sections
+`.fsdocs-member-list` | generated member lists (tables)
+`.fsdocs-member-usage` | usage in generated member lists
+`.fsdocs-member-tooltip` | tooltips in generated member lists
+`.fsdocs-member-xmldoc` | documentation in generated member lists
+`.fsdocs-entity-list` | generated entity lists
+`.fsdocs-entity-name` | generated entity lists
+`.fsdocs-entity-xmldoc` | documentation in generated entity lists
+`.fsdocs-exception-list` | generated exception lists
+`.fsdocs-summary` | the 'summary' section of an XML doc
+`.fsdocs-remarks` | the 'remarks' section of an XML doc
+`.fsdocs-params` | the 'parameters' section of an XML doc
+`.fsdocs-param` | a 'parameter' section of an XML doc
+`.fsdocs-param-name` | a 'parameter' name of an XML doc
+`.fsdocs-returns` | the 'returns' section of an XML doc
+`.fsdocs-example` | the 'example' section of an XML doc
+`.fsdocs-note` | the 'notes' section of an XML doc
+`.fsdocs-para` | a paragraph of an XML doc
+
+
+Some generated elements are given specific HTML ids:
+
+HTML element selector | Content
+:--- | :---
+`header` | The navigation-bar
+`#fsdocs-main-menu` | The main menu on the left side
+`#content` | The generated content
+`#fsdocs-page-menu` | The sub menu on the right side
+`dialog` | The search dialog
+`dialog input[type=search]` | The search box
+`#fsdocs-logo` | The logo
+
+
+If you write a new theme by CSS styling please contribute it back to FSharp.Formatting.
+
+## Customizing via a new template
+
+You can do advanced styling by creating a new template. Add a file `docs/_template.html`, likely starting
+with the existing default template.
+
+> NOTE: To enable hot reload during development with `fsdocs watch` in a custom `_template.html` file,
+make sure to add the single line `{{fsdocs-watch-script}}` to your `` tag.
+NOTE: There is no guarantee that your template will continue to work with future versions of F# Formatting.
+If you do develop a good template please consider contributing it back to F# Formatting.
+>
+
+## Customizing menu items by template
+
+You can add advanced styling to the sidebar generated menu items by creating a new template for it.
+`fsdoc` will look for menu templates in the `--input` folder which defaults to the docs folder.
+
+To customize the generated menu-item headers, use file `_menu_template.html` with starting template:
+
+```html
+
+ {{fsdocs-menu-header-content}}
+
+{{fsdocs-menu-items}}
+```
+
+Similarly, to customize the individual menu item list, use file `_menu-item_template.html` with starting template:
+
+```html
+
+```
+
+Do note that files need to be added prior running or won't be generated.
+In case you want to get a unique identifier for a header or menu item, you can use `{{fsdocs-menu-header-id}}`
+and `{{fsdocs-menu-item-id}}`, respectively.
+
+## Injecting additional html into the default template
+
+Occasionally, you may find the need to make small customizations to the default template, such as adding a Google
+Analytics snippet or including additional style or script tags. To address this scenario, you can create two
+files: `_head.html` and/or `_body.html`.
+
+The content within these files will serve as replacements for the `{{fsdocs-head-extra}}` and `{{fsdocs-body-extra}}`
+placeholders, which are utilized in the default template.
+
+## Customizing by generating your own site using your own code
+
+The `FSharp.Formatting.ApiDocs` namespace includes a `GenerateModel` that captures
+the results of documentation preparation in `ApiDocsModel` and allows you to
+generate your own site using your own code.
+
+> NOTE: The ApiDocsModel API is undergoing change and improvement and there is no guarantee that your bespoke site
+generation will continue to work
+with future versions of F# Formatting.
+NOTE: The `ApiDocsModel` currently includes some generated HTML with some specific style tags.
+In the long term these may be removed from the design of that component.
+>
+
+
diff --git a/styling.tex b/styling.tex
new file mode 100644
index 000000000..be65fe35b
--- /dev/null
+++ b/styling.tex
@@ -0,0 +1,302 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Customization and Styling}
+
+
+
+When using \texttt{fsdocs}, there are six levels of extra content development and styling.
+\begin{enumerate}
+\item
+
+Don't do any styling or documentation customization and simply write content. This is by far the simplest option to
+maintain.
+
+\item
+
+Add content such as an \texttt{docs/index.md} to customize the front-page content for your generated docs.
+You can also add content such as \texttt{docs/reference/fslib.md} to give a bespoke landing page
+for one of your namespaces, e.g. here assumed to be \texttt{namespace FsLib}. This will override any
+generated content.
+
+\item
+
+Customize via Styling Parameters
+
+\item
+
+Customize via CSS
+
+\item
+
+Customize via a new template
+
+\item
+
+Customize by generating your own site using your own code
+
+\end{enumerate}
+
+
+
+By default \texttt{fsdocs} does no styling customization and uses the following defaults. These are the settings used to build
+this site.
+\begin{itemize}
+\item
+
+Uses the default template
+in \href{https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/\_template.html}{docs/\_template.html}
+
+\item
+
+Uses the default styles
+in \href{https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css}{docs/content/fsdocs-default.css}.
+
+\item
+
+Uses no custom styles
+in \href{https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css}{docs/content/fsdocs-custom.css}.
+
+\item
+
+Uses no styling parameters except those extracted from the project files.
+
+\end{itemize}
+
+
+
+For your project, you don't need any of these files. However you can add them if you wish, though if
+you adjust them there is no guarantee that your template will continue to work with future versions of F\# Formatting.
+\subsection*{Customizing via Styling Parameters}
+
+
+
+The following \href{content.html}{content parameters} are particularly related to visual styling:
+\begin{tabular}{|l|l|}\hline
+\textbf{Substitution name} & \textbf{Value (if not overriden by --parameters)}\\ \hline\hline
+\texttt{fsdocs-authors} & \texttt{}\\ \hline
+\texttt{fsdocs-license-link} & \texttt{}\\ \hline
+\texttt{fsdocs-logo-src} & \texttt{}\\ \hline
+\texttt{fsdocs-favicon-src} & \texttt{}\\ \hline
+\texttt{fsdocs-logo-link} & \texttt{}\\ \hline
+\texttt{fsdocs-release-notes-link} & \texttt{} else \texttt{/blob/master/RELEASE\_NOTES.md}\\ \hline
+\texttt{fsdocs-repository-link} & \texttt{}\\ \hline
+\texttt{fsdocs-theme} & \texttt{}, must currently be \texttt{default}\\ \hline
+\end{tabular}
+
+
+
+These basic entry-level styling parameters can be set in the project file or \texttt{Directory.Build.props}.
+For example:
+\begin{lstlisting}
+
+
+ https://github.com/foo/bar/blob/master/License.txt
+ https://foo.github.io/bar/
+ https://github.com/foo/bar/
+ https://fsharp.org
+ img/logo.png
+ img/favicon.ico
+ https://github.com/foo/bar/blob/master/License.txt
+ https://github.com/foo/bar/blob/master/release-notes.md
+ true
+ default
+
+
+\end{lstlisting}
+
+
+As an example, here is \href{templates/leftside/styling.html}{a page with alternative styling}.
+\subsection*{Customizing via CSS}
+
+
+
+You can start styling by creating a file \texttt{docs/content/fsdocs-theme.css} and adding entries to it.
+
+It is loaded by the standard template.
+\subsubsection*{CSS variables}
+
+
+
+The default template is heavily based
+on \href{https://developer.mozilla.org/en-US/docs/Web/CSS/Using\_CSS\_custom\_properties}{CSS variables}. These can easily be
+override to customize the look and feel of the default theme.
+
+A full list of the overrideable variables can be
+found \href{https://github.com/fsprojects/FSharp.Formatting/blob/main/docs/content/fsdocs-default.css}{here}.
+\begin{lstlisting}
+:root {
+ --text-color: red;
+}
+
+[data-theme=dark] {
+ --text-color: darkred;
+}
+
+\end{lstlisting}
+
+
+Please be aware that the \texttt{dark} mode in the default theme is using the same variables.
+When you override a variable, it will also be used in \texttt{dark} mode unless redefined in a \texttt{[data-theme=dark]} CSS query.
+\subsubsection*{CSS classes}
+
+
+
+The API documentation uses a set of fixed CSS classes:
+\begin{tabular}{|l|l|}\hline
+\textbf{CSS class} & \textbf{Corresponding Content}\\ \hline\hline
+\texttt{.fsdocs-tip} & generated tooltips\\ \hline
+\texttt{.fsdocs-xmldoc} & generated xmldoc sections\\ \hline
+\texttt{.fsdocs-member-list} & generated member lists (tables)\\ \hline
+\texttt{.fsdocs-member-usage} & usage in generated member lists\\ \hline
+\texttt{.fsdocs-member-tooltip} & tooltips in generated member lists\\ \hline
+\texttt{.fsdocs-member-xmldoc} & documentation in generated member lists\\ \hline
+\texttt{.fsdocs-entity-list} & generated entity lists\\ \hline
+\texttt{.fsdocs-entity-name} & generated entity lists\\ \hline
+\texttt{.fsdocs-entity-xmldoc} & documentation in generated entity lists\\ \hline
+\texttt{.fsdocs-exception-list} & generated exception lists\\ \hline
+\texttt{.fsdocs-summary} & the 'summary' section of an XML doc\\ \hline
+\texttt{.fsdocs-remarks} & the 'remarks' section of an XML doc\\ \hline
+\texttt{.fsdocs-params} & the 'parameters' section of an XML doc\\ \hline
+\texttt{.fsdocs-param} & a 'parameter' section of an XML doc\\ \hline
+\texttt{.fsdocs-param-name} & a 'parameter' name of an XML doc\\ \hline
+\texttt{.fsdocs-returns} & the 'returns' section of an XML doc\\ \hline
+\texttt{.fsdocs-example} & the 'example' section of an XML doc\\ \hline
+\texttt{.fsdocs-note} & the 'notes' section of an XML doc\\ \hline
+\texttt{.fsdocs-para} & a paragraph of an XML doc\\ \hline
+\end{tabular}
+
+
+
+Some generated elements are given specific HTML ids:
+\begin{tabular}{|l|l|}\hline
+\textbf{HTML element selector} & \textbf{Content}\\ \hline\hline
+\texttt{header} & The navigation-bar\\ \hline
+\texttt{\#fsdocs-main-menu} & The main menu on the left side\\ \hline
+\texttt{\#content} & The generated content\\ \hline
+\texttt{\#fsdocs-page-menu} & The sub menu on the right side\\ \hline
+\texttt{dialog} & The search dialog\\ \hline
+\texttt{dialog input[type=search]} & The search box\\ \hline
+\texttt{\#fsdocs-logo} & The logo\\ \hline
+\end{tabular}
+
+
+
+If you write a new theme by CSS styling please contribute it back to FSharp.Formatting.
+\subsection*{Customizing via a new template}
+
+
+
+You can do advanced styling by creating a new template. Add a file \texttt{docs/\_template.html}, likely starting
+with the existing default template.
+\begin{quote}
+
+
+NOTE: To enable hot reload during development with \texttt{fsdocs watch} in a custom \texttt{\_template.html} file,
+make sure to add the single line \texttt{\{\{fsdocs-watch-script\}\}} to your \texttt{} tag.
+NOTE: There is no guarantee that your template will continue to work with future versions of F\# Formatting.
+If you do develop a good template please consider contributing it back to F\# Formatting.
+\end{quote}
+
+\subsection*{Customizing menu items by template}
+
+
+
+You can add advanced styling to the sidebar generated menu items by creating a new template for it.
+\texttt{fsdoc} will look for menu templates in the \texttt{--input} folder which defaults to the docs folder.
+
+
+To customize the generated menu-item headers, use file \texttt{\_menu\_template.html} with starting template:
+\begin{lstlisting}
+
+ {{fsdocs-menu-header-content}}
+
+{{fsdocs-menu-items}}
+
+\end{lstlisting}
+
+
+Similarly, to customize the individual menu item list, use file \texttt{\_menu-item\_template.html} with starting template:
+\begin{lstlisting}
+
+
+\end{lstlisting}
+
+
+Do note that files need to be added prior running or won't be generated.
+In case you want to get a unique identifier for a header or menu item, you can use \texttt{\{\{fsdocs-menu-header-id\}\}}
+and \texttt{\{\{fsdocs-menu-item-id\}\}}, respectively.
+\subsection*{Injecting additional html into the default template}
+
+
+
+Occasionally, you may find the need to make small customizations to the default template, such as adding a Google
+Analytics snippet or including additional style or script tags. To address this scenario, you can create two
+files: \texttt{\_head.html} and/or \texttt{\_body.html}.
+
+
+The content within these files will serve as replacements for the \texttt{\{\{fsdocs-head-extra\}\}} and \texttt{\{\{fsdocs-body-extra\}\}}
+placeholders, which are utilized in the default template.
+\subsection*{Customizing by generating your own site using your own code}
+
+
+
+The \texttt{FSharp.Formatting.ApiDocs} namespace includes a \texttt{GenerateModel} that captures
+the results of documentation preparation in \texttt{ApiDocsModel} and allows you to
+generate your own site using your own code.
+\begin{quote}
+
+
+NOTE: The ApiDocsModel API is undergoing change and improvement and there is no guarantee that your bespoke site
+generation will continue to work
+with future versions of F\# Formatting.
+NOTE: The \texttt{ApiDocsModel} currently includes some generated HTML with some specific style tags.
+In the long term these may be removed from the design of that component.
+\end{quote}
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/templates/leftside/styling.fsx b/templates/leftside/styling.fsx
new file mode 100644
index 000000000..12a3abf2c
--- /dev/null
+++ b/templates/leftside/styling.fsx
@@ -0,0 +1,29 @@
+(**
+# Example: Styling for Right-Side Navigation Bar
+
+
+The sidebar can be moved to the right by overwriting the following CSS variables in your `fsdocs-theme.css` file:
+
+```css
+:root {
+ --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);
+ --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);
+ --main-menu-grid-column: 2;
+ --main-grid-column: 1;
+}
+```
+
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
+
+*)
+
diff --git a/templates/leftside/styling.html b/templates/leftside/styling.html
new file mode 100644
index 000000000..659768145
--- /dev/null
+++ b/templates/leftside/styling.html
@@ -0,0 +1,343 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Example: Styling for Right-Side Navigation Bar
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/templates/leftside/styling.ipynb b/templates/leftside/styling.ipynb
new file mode 100644
index 000000000..bd1bfa720
--- /dev/null
+++ b/templates/leftside/styling.ipynb
@@ -0,0 +1,89 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Example: Styling for Right-Side Navigation Bar\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "\u003cstyle\u003e\n",
+ ":root {\n",
+ " --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);\n",
+ " --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);\n",
+ " --main-menu-grid-column: 2;\n",
+ " --main-grid-column: 1;\n",
+ "}\n",
+ "\u003c/style\u003e\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "The sidebar can be moved to the right by overwriting the following CSS variables in your `fsdocs-theme.css` file:\n",
+ "\n",
+ "```css\n",
+ ":root {\n",
+ " --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);\n",
+ " --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);\n",
+ " --main-menu-grid-column: 2;\n",
+ " --main-grid-column: 1;\n",
+ "}\n",
+ "```\n",
+ "\n",
+ "\n",
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n",
+ "\n",
+ "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/templates/leftside/styling.md b/templates/leftside/styling.md
new file mode 100644
index 000000000..1ce33ed9c
--- /dev/null
+++ b/templates/leftside/styling.md
@@ -0,0 +1,27 @@
+# Example: Styling for Right-Side Navigation Bar
+
+
+The sidebar can be moved to the right by overwriting the following CSS variables in your `fsdocs-theme.css` file:
+
+```css
+:root {
+ --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);
+ --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);
+ --main-menu-grid-column: 2;
+ --main-grid-column: 1;
+}
+```
+
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
+
+
diff --git a/templates/leftside/styling.tex b/templates/leftside/styling.tex
new file mode 100644
index 000000000..2f5f87e72
--- /dev/null
+++ b/templates/leftside/styling.tex
@@ -0,0 +1,77 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Example: Styling for Right-Side Navigation Bar}
+
+
+
+
+The sidebar can be moved to the right by overwriting the following CSS variables in your \texttt{fsdocs-theme.css} file:
+\begin{lstlisting}
+:root {
+ --body-grid-template-columns: minmax(0, 1fr) var(--main-menu-width);
+ --body-grid-template-columns-xl: minmax(0, 1fr) var(--main-menu-width) var(--page-menu-width);
+ --main-menu-grid-column: 2;
+ --main-grid-column: 1;
+}
+
+\end{lstlisting}
+
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+
+Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
+
+
+\end{document}
\ No newline at end of file
diff --git a/upgrade.fsx b/upgrade.fsx
new file mode 100644
index 000000000..b4c39b0a1
--- /dev/null
+++ b/upgrade.fsx
@@ -0,0 +1,83 @@
+(**
+# Upgrading to fsdocs
+
+Here are the typical steps to upgrade a repo based on `ProjectScaffold` to use `fsdocs`
+
+0 Run
+
+
+ [lang=text]
+ dotnet new tool
+ dotnet tool install fsdocs-tool
+
+
+1 Delete all of `docs\tools` particularly `docs\tool\generate.fsx`. Keep a copy of any templates for reference as you'll have to copy some bits across to the new template.
+
+
+2 Put your docs directory so it reflects the final shape of the site. For example move the content of `docs\input\*` and `docs\files\*` directly to `docs\*`
+
+
+3 Follow the notes in [styling](styling.html) to start to style your site.
+
+
+4 Run
+
+
+ [lang=text]
+ dotnet fsdocs watch
+
+
+ and edit and test your docs.
+
+
+5 If using FAKE adjust `build.fsx` e.g.
+
+
+ [lang=text]
+ Target.create "GenerateDocs" (fun _ ->
+ Shell.cleanDir ".fsdocs"
+ DotNet.exec id "fsdocs" "build --clean" |> ignore
+ )
+
+ Target.create "ReleaseDocs" (fun _ ->
+ Git.Repository.clone "" projectRepo "temp/gh-pages"
+ Git.Branches.checkoutBranch "temp/gh-pages" "gh-pages"
+ Shell.copyRecursive "output" "temp/gh-pages" true |> printfn "%A"
+ Git.CommandHelper.runSimpleGitCommand "temp/gh-pages" "add ." |> printfn "%s"
+ let cmd = sprintf """commit -a -m "Update generated documentation for version %s""" release.NugetVersion
+ Git.CommandHelper.runSimpleGitCommand "temp/gh-pages" cmd |> printfn "%s"
+ Git.Branches.push "temp/gh-pages"
+ )
+
+
+6 Consider creating `docs\_template.fsx` and `docs\_template.ipynb` to enable co-generation of F# scripts and F# notebooks.
+
+
+ If you add support for notebooks and scripts, consider adding mybinder links to each of your literate executable content pages. For example [like this](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/literate.fsx#L19).
+
+
+ Also add load sections to make sure your notebooks and scripts contain the right content to load packages out of repo. For example [like this](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/literate.fsx#L1).
+
+
+Sample commands:
+
+ [lang=text]
+ dotnet tool install fsdocs-tool --local
+ git add dotnet-tools.json
+ git rm -fr docs/tools
+ git mv docs/input/* docs
+ git mv docs/files/* docs
+
+
+
+ dotnet fsdocs watch
+
+ touch docs/_template.fsx
+ touch docs/_template.ipynb
+ git add docs/_template.fsx
+ git add docs/_template.ipynb
+
+Here is an example PR: [https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116](https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116)
+
+*)
+
diff --git a/upgrade.html b/upgrade.html
new file mode 100644
index 000000000..4d08066f8
--- /dev/null
+++ b/upgrade.html
@@ -0,0 +1,383 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Upgrading to fsdocs
+ | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Here are the typical steps to upgrade a repo based on ProjectScaffold to use fsdocs
+
+
+
Run
+
dotnet new tool
+dotnet tool install fsdocs-tool
+
+
+
Delete all of docs\tools particularly docs\tool\generate.fsx. Keep a copy of any templates for reference as you'll have to copy some bits across to the new template.
+
Put your docs directory so it reflects the final shape of the site. For example move the content of docs\input\* and docs\files\* directly to docs\*
+
Follow the notes in styling to start to style your site.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/users.ipynb b/users.ipynb
new file mode 100644
index 000000000..2fc3eeae8
--- /dev/null
+++ b/users.ipynb
@@ -0,0 +1,95 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Users of FSharp.Formatting\n",
+ "\n",
+ "The FSharp.Formatting documentation tool is widely used within the F# community.\n",
+ "Here is a non-exhaustive list of projects:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "\u003c!-- temporary --\u003e\n",
+ "\u003cstyle\u003e\n",
+ "table { table-layout: fixed; }\n",
+ "tr td { padding: 15px 0; }\n",
+ "tr td p { margin: 0 }\n",
+ "tr th:first-child, tr td:first-child { width: 20%; }\n",
+ "tr th:last-child, tr td:last-child { width: 35% }\n",
+ "\u003c/style\u003e\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "Project name | Repository | Note\n",
+ "--- | :--- | --- | ---\n",
+ "[FSharp.Formatting](https://fsprojects.github.io/FSharp.Formatting/) | \u0026#32; | [[https://github.com/fsprojects/FSharp.Formatting/](https://github.com/fsprojects/FSharp.Formatting/)](https://github.com/fsprojects/FSharp.Formatting/) | \u0026#32;\n",
+ "[F# compiler guide](https://fsharp.github.io/fsharp-compiler-docs/) | \u0026#32; | [[https://github.com/dotnet/fsharp/](https://github.com/dotnet/fsharp/)](https://github.com/dotnet/fsharp/) | The documentation is generated and published from [[https://github.com/fsharp/fsharp-compiler-docs](https://github.com/fsharp/fsharp-compiler-docs)](https://github.com/fsharp/fsharp-compiler-docs)\n",
+ "[F# Core Library Documentation](https://fsharp.github.io/fsharp-core-docs/) | \u0026#32; | [[https://github.com/dotnet/fsharp/](https://github.com/dotnet/fsharp/)](https://github.com/dotnet/fsharp/) | The documentation is generated and published from [[https://github.com/fsharp/fsharp-core-docs](https://github.com/fsharp/fsharp-core-docs)](https://github.com/fsharp/fsharp-core-docs)\n",
+ "[FsLexYacc](https://fsprojects.github.io/FsLexYacc) | \u0026#32; | [[https://github.com/fsprojects/fslexYacc/](https://github.com/fsprojects/fslexYacc/)](https://github.com/fsprojects/fslexYacc/) | \u0026#32;\n",
+ "[FSharp.Data](https://fsprojects.github.io/FSharp.Data/) | \u0026#32; | [[https://github.com/fsprojects/FSharp.Data/](https://github.com/fsprojects/FSharp.Data/)](https://github.com/fsprojects/FSharp.Data/) | \u0026#32;\n",
+ "[Plotly.NET](https://plotly.net/) | \u0026#32; | [[https://github.com/plotly/Plotly.NET](https://github.com/plotly/Plotly.NET)](https://github.com/plotly/Plotly.NET) | \u0026#32;\n",
+ "[FSharp.Stats](https://fslab.org/FSharp.Stats/) | \u0026#32; | [[https://github.com/fslaborg/FSharp.Stats/](https://github.com/fslaborg/FSharp.Stats/)](https://github.com/fslaborg/FSharp.Stats/) | \u0026#32;\n",
+ "[FsHttp](https://fsprojects.github.io/FsHttp/) | \u0026#32; | [[https://github.com/fsprojects/FsHttp/](https://github.com/fsprojects/FsHttp/)](https://github.com/fsprojects/FsHttp/) | \u0026#32;\n",
+ "[Fantomas](https://fsprojects.github.io/fantomas/docs/) | \u0026#32; | [[https://github.com/fsprojects/fantomas/](https://github.com/fsprojects/fantomas/)](https://github.com/fsprojects/fantomas/) | \u0026#32;\n",
+ "[Telplin](https://nojaf.com/telplin/docs/) | \u0026#32; | [[https://github.com/nojaf/telplin/](https://github.com/nojaf/telplin/)](https://github.com/nojaf/telplin/) | \u0026#32;\n",
+ "[FSharp.Data.Fred](https://github.com/nhirschey/FSharp.Data.Fred/) | \u0026#32; | [[https://github.com/nhirschey/FSharp.Data.Fred/](https://github.com/nhirschey/FSharp.Data.Fred/)](https://github.com/nhirschey/FSharp.Data.Fred/) | \u0026#32;\n",
+ "[N Hirschey Teaching](https://nhirschey.github.io/Teaching/) | \u0026#32; | [[https://github.com/nhirschey/Teaching](https://github.com/nhirschey/Teaching)](https://github.com/nhirschey/Teaching) | \u0026#32;\n",
+ "[FsUnit](https://fsprojects.github.io/FsUnit/) | \u0026#32; | [[https://github.com/fsprojects/FsUnit](https://github.com/fsprojects/FsUnit)](https://github.com/fsprojects/FsUnit) | \u0026#32;\n",
+ "[FAKE](https://fake.build/) | \u0026#32; | [[https://github.com/fsprojects/FAKE](https://github.com/fsprojects/FAKE)](https://github.com/fsprojects/FAKE) | \u0026#32;\n",
+ "[FSharp.Data.GraphQL](https://fsprojects.github.io/FSharp.Data.GraphQL/) | \u0026#32; | [[https://github.com/fsprojects/FSharp.Data.GraphQL](https://github.com/fsprojects/FSharp.Data.GraphQL)](https://github.com/fsprojects/FSharp.Data.GraphQL) | \u0026#32;\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/users.md b/users.md
new file mode 100644
index 000000000..3217b49fe
--- /dev/null
+++ b/users.md
@@ -0,0 +1,33 @@
+# Users of FSharp.Formatting
+
+The FSharp.Formatting documentation tool is widely used within the F# community.
+Here is a non-exhaustive list of projects:
+
+
+
+Project name | Repository | Note
+--- | :--- | --- | ---
+[FSharp.Formatting](https://fsprojects.github.io/FSharp.Formatting/) | | [[https://github.com/fsprojects/FSharp.Formatting/](https://github.com/fsprojects/FSharp.Formatting/)](https://github.com/fsprojects/FSharp.Formatting/) |
+[F# compiler guide](https://fsharp.github.io/fsharp-compiler-docs/) | | [[https://github.com/dotnet/fsharp/](https://github.com/dotnet/fsharp/)](https://github.com/dotnet/fsharp/) | The documentation is generated and published from [[https://github.com/fsharp/fsharp-compiler-docs](https://github.com/fsharp/fsharp-compiler-docs)](https://github.com/fsharp/fsharp-compiler-docs)
+[F# Core Library Documentation](https://fsharp.github.io/fsharp-core-docs/) | | [[https://github.com/dotnet/fsharp/](https://github.com/dotnet/fsharp/)](https://github.com/dotnet/fsharp/) | The documentation is generated and published from [[https://github.com/fsharp/fsharp-core-docs](https://github.com/fsharp/fsharp-core-docs)](https://github.com/fsharp/fsharp-core-docs)
+[FsLexYacc](https://fsprojects.github.io/FsLexYacc) | | [[https://github.com/fsprojects/fslexYacc/](https://github.com/fsprojects/fslexYacc/)](https://github.com/fsprojects/fslexYacc/) |
+[FSharp.Data](https://fsprojects.github.io/FSharp.Data/) | | [[https://github.com/fsprojects/FSharp.Data/](https://github.com/fsprojects/FSharp.Data/)](https://github.com/fsprojects/FSharp.Data/) |
+[Plotly.NET](https://plotly.net/) | | [[https://github.com/plotly/Plotly.NET](https://github.com/plotly/Plotly.NET)](https://github.com/plotly/Plotly.NET) |
+[FSharp.Stats](https://fslab.org/FSharp.Stats/) | | [[https://github.com/fslaborg/FSharp.Stats/](https://github.com/fslaborg/FSharp.Stats/)](https://github.com/fslaborg/FSharp.Stats/) |
+[FsHttp](https://fsprojects.github.io/FsHttp/) | | [[https://github.com/fsprojects/FsHttp/](https://github.com/fsprojects/FsHttp/)](https://github.com/fsprojects/FsHttp/) |
+[Fantomas](https://fsprojects.github.io/fantomas/docs/) | | [[https://github.com/fsprojects/fantomas/](https://github.com/fsprojects/fantomas/)](https://github.com/fsprojects/fantomas/) |
+[Telplin](https://nojaf.com/telplin/docs/) | | [[https://github.com/nojaf/telplin/](https://github.com/nojaf/telplin/)](https://github.com/nojaf/telplin/) |
+[FSharp.Data.Fred](https://github.com/nhirschey/FSharp.Data.Fred/) | | [[https://github.com/nhirschey/FSharp.Data.Fred/](https://github.com/nhirschey/FSharp.Data.Fred/)](https://github.com/nhirschey/FSharp.Data.Fred/) |
+[N Hirschey Teaching](https://nhirschey.github.io/Teaching/) | | [[https://github.com/nhirschey/Teaching](https://github.com/nhirschey/Teaching)](https://github.com/nhirschey/Teaching) |
+[FsUnit](https://fsprojects.github.io/FsUnit/) | | [[https://github.com/fsprojects/FsUnit](https://github.com/fsprojects/FsUnit)](https://github.com/fsprojects/FsUnit) |
+[FAKE](https://fake.build/) | | [[https://github.com/fsprojects/FAKE](https://github.com/fsprojects/FAKE)](https://github.com/fsprojects/FAKE) |
+[FSharp.Data.GraphQL](https://fsprojects.github.io/FSharp.Data.GraphQL/) | | [[https://github.com/fsprojects/FSharp.Data.GraphQL](https://github.com/fsprojects/FSharp.Data.GraphQL)](https://github.com/fsprojects/FSharp.Data.GraphQL) |
+
+
+
diff --git a/users.tex b/users.tex
new file mode 100644
index 000000000..28a83b880
--- /dev/null
+++ b/users.tex
@@ -0,0 +1,83 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Users of FSharp.Formatting}
+
+
+
+The FSharp.Formatting documentation tool is widely used within the F\# community.
+
+Here is a non-exhaustive list of projects:
+
+
+\begin{tabular}{|l|l|l|l|}\hline
+\textbf{Project name} & \textbf{} & \textbf{Repository} & \textbf{Note}\\ \hline\hline
+\href{https://fsprojects.github.io/FSharp.Formatting/}{FSharp.Formatting} & & \href{https://github.com/fsprojects/FSharp.Formatting/}{\href{https://github.com/fsprojects/FSharp.Formatting/}{https://github.com/fsprojects/FSharp.Formatting/}} & \\ \hline
+\href{https://fsharp.github.io/fsharp-compiler-docs/}{F\# compiler guide} & & \href{https://github.com/dotnet/fsharp/}{\href{https://github.com/dotnet/fsharp/}{https://github.com/dotnet/fsharp/}} & The documentation is generated and published from \href{https://github.com/fsharp/fsharp-compiler-docs}{\href{https://github.com/fsharp/fsharp-compiler-docs}{https://github.com/fsharp/fsharp-compiler-docs}}\\ \hline
+\href{https://fsharp.github.io/fsharp-core-docs/}{F\# Core Library Documentation} & & \href{https://github.com/dotnet/fsharp/}{\href{https://github.com/dotnet/fsharp/}{https://github.com/dotnet/fsharp/}} & The documentation is generated and published from \href{https://github.com/fsharp/fsharp-core-docs}{\href{https://github.com/fsharp/fsharp-core-docs}{https://github.com/fsharp/fsharp-core-docs}}\\ \hline
+\href{https://fsprojects.github.io/FsLexYacc}{FsLexYacc} & & \href{https://github.com/fsprojects/fslexYacc/}{\href{https://github.com/fsprojects/fslexYacc/}{https://github.com/fsprojects/fslexYacc/}} & \\ \hline
+\href{https://fsprojects.github.io/FSharp.Data/}{FSharp.Data} & & \href{https://github.com/fsprojects/FSharp.Data/}{\href{https://github.com/fsprojects/FSharp.Data/}{https://github.com/fsprojects/FSharp.Data/}} & \\ \hline
+\href{https://plotly.net/}{Plotly.NET} & & \href{https://github.com/plotly/Plotly.NET}{\href{https://github.com/plotly/Plotly.NET}{https://github.com/plotly/Plotly.NET}} & \\ \hline
+\href{https://fslab.org/FSharp.Stats/}{FSharp.Stats} & & \href{https://github.com/fslaborg/FSharp.Stats/}{\href{https://github.com/fslaborg/FSharp.Stats/}{https://github.com/fslaborg/FSharp.Stats/}} & \\ \hline
+\href{https://fsprojects.github.io/FsHttp/}{FsHttp} & & \href{https://github.com/fsprojects/FsHttp/}{\href{https://github.com/fsprojects/FsHttp/}{https://github.com/fsprojects/FsHttp/}} & \\ \hline
+\href{https://fsprojects.github.io/fantomas/docs/}{Fantomas} & & \href{https://github.com/fsprojects/fantomas/}{\href{https://github.com/fsprojects/fantomas/}{https://github.com/fsprojects/fantomas/}} & \\ \hline
+\href{https://nojaf.com/telplin/docs/}{Telplin} & & \href{https://github.com/nojaf/telplin/}{\href{https://github.com/nojaf/telplin/}{https://github.com/nojaf/telplin/}} & \\ \hline
+\href{https://github.com/nhirschey/FSharp.Data.Fred/}{FSharp.Data.Fred} & & \href{https://github.com/nhirschey/FSharp.Data.Fred/}{\href{https://github.com/nhirschey/FSharp.Data.Fred/}{https://github.com/nhirschey/FSharp.Data.Fred/}} & \\ \hline
+\href{https://nhirschey.github.io/Teaching/}{N Hirschey Teaching} & & \href{https://github.com/nhirschey/Teaching}{\href{https://github.com/nhirschey/Teaching}{https://github.com/nhirschey/Teaching}} & \\ \hline
+\href{https://fsprojects.github.io/FsUnit/}{FsUnit} & & \href{https://github.com/fsprojects/FsUnit}{\href{https://github.com/fsprojects/FsUnit}{https://github.com/fsprojects/FsUnit}} & \\ \hline
+\href{https://fake.build/}{FAKE} & & \href{https://github.com/fsprojects/FAKE}{\href{https://github.com/fsprojects/FAKE}{https://github.com/fsprojects/FAKE}} & \\ \hline
+\href{https://fsprojects.github.io/FSharp.Data.GraphQL/}{FSharp.Data.GraphQL} & & \href{https://github.com/fsprojects/FSharp.Data.GraphQL}{\href{https://github.com/fsprojects/FSharp.Data.GraphQL}{https://github.com/fsprojects/FSharp.Data.GraphQL}} & \\ \hline
+\end{tabular}
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/zero-to-hero.fsx b/zero-to-hero.fsx
new file mode 100644
index 000000000..32531b6c9
--- /dev/null
+++ b/zero-to-hero.fsx
@@ -0,0 +1,267 @@
+(**
+# Getting Started
+
+## From zero to hero: deploying to GitHub Pages
+
+This guide is meant for a typical setup of open-source projects on GitHub.
+We start from a repository without any documentation and aim to end up with a published website on [GitHub Pages](https://pages.github.com/).
+
+## Install the local tool
+
+If you don't have a [dotnet tool manifest](https://learn.microsoft.com/en-us/dotnet/core/tools/local-tools-how-to-use#create-a-manifest-file), you can create one using `dotnet new tool-manifest`.
+
+Next, we can install [fsdocs-tool](https://www.nuget.org/packages/fsdocs-tool/) using `dotnet tool install --local fsdocs-tool`.
+It is recommended to install this tool as a local tool because it allows us to update to newer versions of the tool at our own pace.
+
+## Create the docs folder
+
+After we've installed the tool, we can run `dotnet fsdocs --help` and see the available commands.
+Both `build` and `watch` will generate the documentation for a solution and an input folder.
+The default folder for `--input` is the `./docs` folder, relative to the current working directory.
+
+Typically your project will be structured like:
+
+```
+/repository-root
+ YourSolution.sln
+ ./docs
+ index.md
+ other-file.md
+ ./src
+ ./Project1/Project1.fsproj
+ ./Project2/Project2.fsproj
+```
+
+It is recommended to have a single solution at the root. In some editors, it is more convenient to open a solution at the root, to easily manipulate any file in root repository folder.
+When users clone your repository locally, they cannot be confused on how they need to open the project in their IDE.
+
+⚠️ Please avoid putting your solution in the `src` folder. When we open that solution, it can be more difficult to edit files in the `docs` folder, as we can sometimes only see the `src` folder.
+
+That being said, let's create the `docs` folder and a first Markdown file named `index.md`.
+When `fsdocs` runs, it will transform this `index.md` file to `index.html`, which will be served at the root.
+
+We can put `# Hello world` in the markdown file for now.
+
+Having this in place, should already serve the first page when we start the `watch` command:
+
+> dotnet fsdocs watch
+>
+
+Open [[http://localhost:8901](http://localhost:8901)](http://localhost:8901) and you should see our first page!
+
+🪄 You might notice that there are some images missing. You can add these in the `docs` folder in the right location.
+
+## Generating API documentation
+
+By default, `fsdocs` will generate API documentation for the configured `--projects`.
+When this flag is not specified, `fsdocs` will look for solutions or projects in the working directory.
+It will filter these found projects, the requirements are:
+
+* Having `library`
+
+* Having a binary, so you need to build your project first before the documentation can be generated.
+
+* Not having `true`
+
+* Having `true`
+
+🪄 If you made some changes in order to adhere to the rules, you may want to remove the `.fsdocs/cache` file.
+
+## Adding the missing properties
+
+After our initial `watch` run, you may have noticed that some links aren't working yet.
+`License`, `Releases Notes` and `Source Repository` can be provided by setting MSBuild properties.
+
+You can either add these properties to a single `.fsproj` file, or more typically, add them to a [Directory.Build.props](https://learn.microsoft.com/visualstudio/msbuild/customize-by-directory) file.
+The simplest `Directory.Build.props` file:
+
+```xml
+
+
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md
+ https://fsprojects.github.io/FSharp.AWS.DynamoDB
+
+
+```
+
+🪄 If you don't have any release notes yet, you could consider using [Ionide.KeepAChangelog](https://github.com/ionide/KeepAChangelog).
+
+Running `dotnet fsdocs watch` will now yield:
+
+```
+ root --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/
+ ...
+ fsdocs-license-link --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md
+ fsdocs-release-notes-link --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md
+ ...
+ fsdocs-repository-link --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/
+```
+
+⚠️ Again, you might need to remove `.fsdocs/cache` in order for changes to be picked up!
+
+`` is actually a very important property when you run `dotnet fsdocs build`.
+`build` will generate static files for the targeted production environment. In our case, this will be GitHub Pages.
+
+Pages will host your files from [https://github.com/user/project](https://github.com/user/project) on `https://user.github.io/project/` by default.
+You can change this by adding a custom domain so we need to be sure that all links and urls will be generated correctly during a build.
+
+Let's now run `dotnet fsdocs build`.
+
+`` will replace the `{{root}}` substitution, which is used all over the place in the default template.
+
+⚠️ You want to ensure that the static files in the `output` folder (after running the build) have the correct links.
+
+## Ignore generated files
+
+Alright, at this point we've made a lot of progress. If you are using `git` you want to add the following to your [.gitignore](https://git-scm.com/docs/gitignore) file.
+
+```.ignorelang
+# FSharp.Formatting
+.fsdocs/
+output/
+tmp/
+```
+
+## Ship it!
+
+Once we are satisfied with our documentation, we want to publish it to GitHub Pages.
+We can use [GitHub Actions](https://github.com/features/actions) to deploy our website.
+
+Deploy to Pages from GitHub Actions must be enabled in the repository settings:
+
+
+
+The typical flow is to publish your documentation after a release or after new commits were added to the default branch.
+Let's create a very basic Action that will deploy our website after pushing to main:
+
+Create a file `.github/workflows/docs.yml`:
+
+```yml
+name: Docs
+
+# Trigger this Action when new code is pushed to the main branch
+on:
+ push:
+ branches:
+ - main
+
+# We need some permissions to publish to Github Pages
+permissions:
+ contents: write
+ pages: write
+ id-token: write
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ # Checkout the source code
+ - uses: actions/checkout@v4
+ # Setup dotnet, please use a global.json to ensure the right SDK is used!
+ - name: Setup .NET
+ uses: actions/setup-dotnet@v3
+ # Restore the local tools
+ - name: Restore tools
+ run: dotnet tool restore
+ # Build the code for the API documentation
+ - name: Build code
+ run: dotnet build -c Release YourSolution.sln
+ # Generate the documentation files
+ - name: Generate the documentation'
+ run: dotnet fsdocs build --properties Configuration=Release
+ # Upload the static files
+ - name: Upload documentation
+ uses: actions/upload-pages-artifact@v2
+ with:
+ path: ./output
+
+ # GitHub Actions recommends deploying in a separate job.
+ deploy:
+ runs-on: ubuntu-latest
+ needs: build
+ steps:
+ - name: Deploy to GitHub Pages
+ id: deployment
+ uses: actions/deploy-pages@v2
+```
+
+⚠️ Careful yaml is indentation sensitive!
+
+## Next steps
+
+Mission accomplished, right? If everything went well, you should have a published website at this point!
+Here are some next steps you could consider:
+
+### Use fsx file in your documentation
+
+Create documentation using [Literate Scripts](../literate.html). A typical flow here is that you load your locate project binary into a script and create examples using the latest code:
+
+```fsharp
+#r "../src/Project1/bin/Debug/net6.0/Project1.dll"
+
+open Project1
+
+// Actual consumption of your project!
+let result = SomeType.SomeMethod("foo")
+```
+
+When using the `--strict` flag in `dotnet fsdocs build`, your documentation generation will fail if your script contains errors.
+This is useful to ensure your documentation is always in sync with your latest public API!
+
+### Automatically update to newer versions of fsdocs-tool
+
+Using [Dependabot](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/about-dependabot-version-updates) you can easily receive new PR's with updates to your `dotnet` dependencies.
+
+Create a `.github/dependabot.yml` file with:
+
+```yml
+version: 2
+updates:
+ # Update to newer version of GitHub Actions
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+
+ # Update to newer NuGet dependencies
+ - package-ecosystem: "nuget"
+ directory: "/"
+ schedule:
+ interval: "daily"
+```
+
+This will automatically create a new PR when there is an update to the `fsdocs` tool.
+
+⚠️ P️lease be very careful, if you have followed along, we don't have any GitHub Actions right now that run against pull requests!
+It is recommended to have an Action that builds your documentation against any incoming changes.
+You typically want to lint code, run unit tests and perform other useful checks as well!
+
+Example Action, `.github/workflows/ci.yml`:
+
+```yml
+name: CI
+
+on: [pull_request]
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v3
+ - name: Setup .NET Core
+ uses: actions/setup-dotnet@v3
+ - name: Restore tools
+ run: dotnet tool restore
+ - name: Build
+ run: dotnet build YourSolution.sln
+ - name: Documentation
+ run: dotnet fsdocs build
+```
+
+⚠️ Also never trust any update to `fsdocs` blindly, always check the [release notes](https://github.com/fsprojects/FSharp.Formatting/blob/main/RELEASE_NOTES.md) to see if there are any breaking changes.
+
+*)
+
diff --git a/zero-to-hero.html b/zero-to-hero.html
new file mode 100644
index 000000000..1c28093f1
--- /dev/null
+++ b/zero-to-hero.html
@@ -0,0 +1,566 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Getting Started | FSharp.Formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This guide is meant for a typical setup of open-source projects on GitHub.
+We start from a repository without any documentation and aim to end up with a published website on GitHub Pages.
If you don't have a dotnet tool manifest, you can create one using dotnet new tool-manifest.
+
Next, we can install fsdocs-tool using dotnet tool install --local fsdocs-tool.
+It is recommended to install this tool as a local tool because it allows us to update to newer versions of the tool at our own pace.
After we've installed the tool, we can run dotnet fsdocs --help and see the available commands.
+Both build and watch will generate the documentation for a solution and an input folder.
+The default folder for --input is the ./docs folder, relative to the current working directory.
It is recommended to have a single solution at the root. In some editors, it is more convenient to open a solution at the root, to easily manipulate any file in root repository folder.
+When users clone your repository locally, they cannot be confused on how they need to open the project in their IDE.
+
⚠️ Please avoid putting your solution in the src folder. When we open that solution, it can be more difficult to edit files in the docs folder, as we can sometimes only see the src folder.
+
That being said, let's create the docs folder and a first Markdown file named index.md.
+When fsdocs runs, it will transform this index.md file to index.html, which will be served at the root.
+
We can put # Hello world in the markdown file for now.
+
Having this in place, should already serve the first page when we start the watch command:
By default, fsdocs will generate API documentation for the configured --projects.
+When this flag is not specified, fsdocs will look for solutions or projects in the working directory.
+It will filter these found projects, the requirements are:
+
+
Having <OutputType>library</OutputType>
+
Having a binary, so you need to build your project first before the documentation can be generated.
+
Not having <IsTestProject>true</IsTestProject>
+
Having <GenerateDocumentationFile>true</GenerateDocumentationFile>
+
+
🪄 If you made some changes in order to adhere to the rules, you may want to remove the .fsdocs/cache file.
After our initial watch run, you may have noticed that some links aren't working yet.
+License, Releases Notes and Source Repository can be provided by setting MSBuild properties.
+
You can either add these properties to a single .fsproj file, or more typically, add them to a Directory.Build.props file.
+The simplest Directory.Build.props file:
⚠️ Again, you might need to remove .fsdocs/cache in order for changes to be picked up!
+
<PackageProjectUrl> is actually a very important property when you run dotnet fsdocs build.
+build will generate static files for the targeted production environment. In our case, this will be GitHub Pages.
+
Pages will host your files from https://github.com/user/project on https://user.github.io/project/ by default.
+You can change this by adding a custom domain so we need to be sure that all links and urls will be generated correctly during a build.
+
Let's now run dotnet fsdocs build.
+
<PackageProjectUrl> will replace the {{root}} substitution, which is used all over the place in the default template.
+
⚠️ You want to ensure that the static files in the output folder (after running the build) have the correct links.
Once we are satisfied with our documentation, we want to publish it to GitHub Pages.
+We can use GitHub Actions to deploy our website.
+
Deploy to Pages from GitHub Actions must be enabled in the repository settings:
+
+
The typical flow is to publish your documentation after a release or after new commits were added to the default branch.
+Let's create a very basic Action that will deploy our website after pushing to main:
+
Create a file .github/workflows/docs.yml:
+
name: Docs
+
+# Trigger this Action when new code is pushed to the main branch
+on:
+ push:
+ branches:
+ - main
+
+# We need some permissions to publish to Github Pages
+permissions:
+ contents: write
+ pages: write
+ id-token: write
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ # Checkout the source code
+ - uses: actions/checkout@v4
+ # Setup dotnet, please use a global.json to ensure the right SDK is used!
+ - name: Setup .NET
+ uses: actions/setup-dotnet@v3
+ # Restore the local tools
+ - name: Restore tools
+ run: dotnet tool restore
+ # Build the code for the API documentation
+ - name: Build code
+ run: dotnet build -c Release YourSolution.sln
+ # Generate the documentation files
+ - name: Generate the documentation'
+ run: dotnet fsdocs build --properties Configuration=Release
+ # Upload the static files
+ - name: Upload documentation
+ uses: actions/upload-pages-artifact@v2
+ with:
+ path: ./output
+
+ # GitHub Actions recommends deploying in a separate job.
+ deploy:
+ runs-on: ubuntu-latest
+ needs: build
+ steps:
+ - name: Deploy to GitHub Pages
+ id: deployment
+ uses: actions/deploy-pages@v2
+
Create documentation using Literate Scripts. A typical flow here is that you load your locate project binary into a script and create examples using the latest code:
+
#r"../src/Project1/bin/Debug/net6.0/Project1.dll"
+
+openProject1
+
+// Actual consumption of your project!
+letresult=SomeType.SomeMethod("foo")
+
+
When using the --strict flag in dotnet fsdocs build, your documentation generation will fail if your script contains errors.
+This is useful to ensure your documentation is always in sync with your latest public API!
This will automatically create a new PR when there is an update to the fsdocs tool.
+
⚠️ P️lease be very careful, if you have followed along, we don't have any GitHub Actions right now that run against pull requests!
+It is recommended to have an Action that builds your documentation against any incoming changes.
+You typically want to lint code, run unit tests and perform other useful checks as well!
⚠️ Also never trust any update to fsdocs blindly, always check the release notes to see if there are any breaking changes.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/zero-to-hero.ipynb b/zero-to-hero.ipynb
new file mode 100644
index 000000000..fe6a1cb52
--- /dev/null
+++ b/zero-to-hero.ipynb
@@ -0,0 +1,304 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Getting Started\n",
+ "\n",
+ "## From zero to hero: deploying to GitHub Pages\n",
+ "\n",
+ "This guide is meant for a typical setup of open-source projects on GitHub.\n",
+ "We start from a repository without any documentation and aim to end up with a published website on [GitHub Pages](https://pages.github.com/).\n",
+ "\n",
+ "## Install the local tool\n",
+ "\n",
+ "If you don\u0027t have a [dotnet tool manifest](https://learn.microsoft.com/en-us/dotnet/core/tools/local-tools-how-to-use#create-a-manifest-file), you can create one using `dotnet new tool-manifest`.\n",
+ "\n",
+ "Next, we can install [fsdocs-tool](https://www.nuget.org/packages/fsdocs-tool/) using `dotnet tool install --local fsdocs-tool`.\n",
+ "It is recommended to install this tool as a local tool because it allows us to update to newer versions of the tool at our own pace.\n",
+ "\n",
+ "## Create the docs folder\n",
+ "\n",
+ "After we\u0027ve installed the tool, we can run `dotnet fsdocs --help` and see the available commands.\n",
+ "Both `build` and `watch` will generate the documentation for a solution and an input folder.\n",
+ "The default folder for `--input` is the `./docs` folder, relative to the current working directory.\n",
+ "\n",
+ "Typically your project will be structured like:\n",
+ "\n",
+ "```\n",
+ "/repository-root\n",
+ " YourSolution.sln\n",
+ " ./docs\n",
+ " index.md\n",
+ " other-file.md\n",
+ " ./src\n",
+ " ./Project1/Project1.fsproj\n",
+ " ./Project2/Project2.fsproj\n",
+ "```\n",
+ "\n",
+ "It is recommended to have a single solution at the root. In some editors, it is more convenient to open a solution at the root, to easily manipulate any file in root repository folder.\n",
+ "When users clone your repository locally, they cannot be confused on how they need to open the project in their IDE.\n",
+ "\n",
+ "⚠️ Please avoid putting your solution in the `src` folder. When we open that solution, it can be more difficult to edit files in the `docs` folder, as we can sometimes only see the `src` folder.\n",
+ "\n",
+ "That being said, let\u0027s create the `docs` folder and a first Markdown file named `index.md`.\n",
+ "When `fsdocs` runs, it will transform this `index.md` file to `index.html`, which will be served at the root.\n",
+ "\n",
+ "We can put `# Hello world` in the markdown file for now.\n",
+ "\n",
+ "Having this in place, should already serve the first page when we start the `watch` command:\n",
+ "\n",
+ "\u003e dotnet fsdocs watch\n",
+ "\u003e \n",
+ "\n",
+ "Open [[http://localhost:8901](http://localhost:8901)](http://localhost:8901) and you should see our first page!\n",
+ "\n",
+ "🪄 You might notice that there are some images missing. You can add these in the `docs` folder in the right location.\n",
+ "\n",
+ "## Generating API documentation\n",
+ "\n",
+ "By default, `fsdocs` will generate API documentation for the configured `--projects`.\n",
+ "When this flag is not specified, `fsdocs` will look for solutions or projects in the working directory.\n",
+ "It will filter these found projects, the requirements are:\n",
+ "\n",
+ "* Having `\u003cOutputType\u003elibrary\u003c/OutputType\u003e`\n",
+ "\n",
+ "* Having a binary, so you need to build your project first before the documentation can be generated.\n",
+ "\n",
+ "* Not having `\u003cIsTestProject\u003etrue\u003c/IsTestProject\u003e`\n",
+ "\n",
+ "* Having `\u003cGenerateDocumentationFile\u003etrue\u003c/GenerateDocumentationFile\u003e`\n",
+ "\n",
+ "🪄 If you made some changes in order to adhere to the rules, you may want to remove the `.fsdocs/cache` file.\n",
+ "\n",
+ "## Adding the missing properties\n",
+ "\n",
+ "After our initial `watch` run, you may have noticed that some links aren\u0027t working yet.\n",
+ "`License`, `Releases Notes` and `Source Repository` can be provided by setting MSBuild properties.\n",
+ "\n",
+ "You can either add these properties to a single `.fsproj` file, or more typically, add them to a [Directory.Build.props](https://learn.microsoft.com/visualstudio/msbuild/customize-by-directory) file.\n",
+ "The simplest `Directory.Build.props` file:\n",
+ "\n",
+ "```xml\n",
+ "\u003cProject\u003e\n",
+ " \u003cPropertyGroup\u003e\n",
+ " \u003cRepositoryUrl\u003ehttps://github.com/fsprojects/FSharp.AWS.DynamoDB\u003c/RepositoryUrl\u003e\n",
+ " \u003cFsDocsLicenseLink\u003ehttps://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md\u003c/FsDocsLicenseLink\u003e\n",
+ " \u003cFsDocsReleaseNotesLink\u003ehttps://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md\u003c/FsDocsReleaseNotesLink\u003e\n",
+ " \u003cPackageProjectUrl\u003ehttps://fsprojects.github.io/FSharp.AWS.DynamoDB\u003c/PackageProjectUrl\u003e\n",
+ " \u003c/PropertyGroup\u003e\n",
+ "\u003c/Project\u003e\n",
+ "```\n",
+ "\n",
+ "🪄 If you don\u0027t have any release notes yet, you could consider using [Ionide.KeepAChangelog](https://github.com/ionide/KeepAChangelog).\n",
+ "\n",
+ "Running `dotnet fsdocs watch` will now yield:\n",
+ "\n",
+ "```\n",
+ " root --\u003e https://github.com/fsprojects/FSharp.AWS.DynamoDB/\n",
+ " ...\n",
+ " fsdocs-license-link --\u003e https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md\n",
+ " fsdocs-release-notes-link --\u003e https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md\n",
+ " ...\n",
+ " fsdocs-repository-link --\u003e https://github.com/fsprojects/FSharp.AWS.DynamoDB/\n",
+ "```\n",
+ "\n",
+ "⚠️ Again, you might need to remove `.fsdocs/cache` in order for changes to be picked up!\n",
+ "\n",
+ "`\u003cPackageProjectUrl\u003e` is actually a very important property when you run `dotnet fsdocs build`.\n",
+ "`build` will generate static files for the targeted production environment. In our case, this will be GitHub Pages.\n",
+ "\n",
+ "Pages will host your files from [https://github.com/user/project](https://github.com/user/project) on `https://user.github.io/project/` by default.\n",
+ "You can change this by adding a custom domain so we need to be sure that all links and urls will be generated correctly during a build.\n",
+ "\n",
+ "Let\u0027s now run `dotnet fsdocs build`.\n",
+ "\n",
+ "`\u003cPackageProjectUrl\u003e` will replace the `{{root}}` substitution, which is used all over the place in the default template.\n",
+ "\n",
+ "⚠️ You want to ensure that the static files in the `output` folder (after running the build) have the correct links.\n",
+ "\n",
+ "## Ignore generated files\n",
+ "\n",
+ "Alright, at this point we\u0027ve made a lot of progress. If you are using `git` you want to add the following to your [.gitignore](https://git-scm.com/docs/gitignore) file.\n",
+ "\n",
+ "```.ignorelang\n",
+ "# FSharp.Formatting\n",
+ ".fsdocs/\n",
+ "output/\n",
+ "tmp/\n",
+ "```\n",
+ "\n",
+ "## Ship it!\n",
+ "\n",
+ "Once we are satisfied with our documentation, we want to publish it to GitHub Pages.\n",
+ "We can use [GitHub Actions](https://github.com/features/actions) to deploy our website.\n",
+ "\n",
+ "Deploy to Pages from GitHub Actions must be enabled in the repository settings:\n",
+ "\n",
+ "\n",
+ "\n",
+ "The typical flow is to publish your documentation after a release or after new commits were added to the default branch.\n",
+ "Let\u0027s create a very basic Action that will deploy our website after pushing to main:\n",
+ "\n",
+ "Create a file `.github/workflows/docs.yml`:\n",
+ "\n",
+ "```yml\n",
+ "name: Docs\n",
+ "\n",
+ "# Trigger this Action when new code is pushed to the main branch\n",
+ "on:\n",
+ " push:\n",
+ " branches:\n",
+ " - main\n",
+ "\n",
+ "# We need some permissions to publish to Github Pages\n",
+ "permissions:\n",
+ " contents: write\n",
+ " pages: write\n",
+ " id-token: write\n",
+ "\n",
+ "jobs:\n",
+ " build:\n",
+ " runs-on: ubuntu-latest\n",
+ " steps:\n",
+ " # Checkout the source code\n",
+ " - uses: actions/checkout@v4\n",
+ " # Setup dotnet, please use a global.json to ensure the right SDK is used!\n",
+ " - name: Setup .NET\n",
+ " uses: actions/setup-dotnet@v3\n",
+ " # Restore the local tools\n",
+ " - name: Restore tools\n",
+ " run: dotnet tool restore\n",
+ " # Build the code for the API documentation\n",
+ " - name: Build code\n",
+ " run: dotnet build -c Release YourSolution.sln\n",
+ " # Generate the documentation files\n",
+ " - name: Generate the documentation\u0027\n",
+ " run: dotnet fsdocs build --properties Configuration=Release\n",
+ " # Upload the static files\n",
+ " - name: Upload documentation\n",
+ " uses: actions/upload-pages-artifact@v2\n",
+ " with:\n",
+ " path: ./output\n",
+ " \n",
+ " # GitHub Actions recommends deploying in a separate job.\n",
+ " deploy:\n",
+ " runs-on: ubuntu-latest\n",
+ " needs: build\n",
+ " steps:\n",
+ " - name: Deploy to GitHub Pages\n",
+ " id: deployment\n",
+ " uses: actions/deploy-pages@v2\n",
+ "```\n",
+ "\n",
+ "⚠️ Careful yaml is indentation sensitive!\n",
+ "\n",
+ "## Next steps\n",
+ "\n",
+ "Mission accomplished, right? If everything went well, you should have a published website at this point!\n",
+ "Here are some next steps you could consider:\n",
+ "\n",
+ "### Use fsx file in your documentation\n",
+ "\n",
+ "Create documentation using [Literate Scripts](../literate.html). A typical flow here is that you load your locate project binary into a script and create examples using the latest code:\n",
+ "\n",
+ "```fsharp\n",
+ "#r \"../src/Project1/bin/Debug/net6.0/Project1.dll\"\n",
+ "\n",
+ "open Project1\n",
+ "\n",
+ "// Actual consumption of your project!\n",
+ "let result = SomeType.SomeMethod(\"foo\")\n",
+ "```\n",
+ "\n",
+ "When using the `--strict` flag in `dotnet fsdocs build`, your documentation generation will fail if your script contains errors.\n",
+ "This is useful to ensure your documentation is always in sync with your latest public API!\n",
+ "\n",
+ "### Automatically update to newer versions of fsdocs-tool\n",
+ "\n",
+ "Using [Dependabot](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/about-dependabot-version-updates) you can easily receive new PR\u0027s with updates to your `dotnet` dependencies.\n",
+ "\n",
+ "Create a `.github/dependabot.yml` file with:\n",
+ "\n",
+ "```yml\n",
+ "version: 2\n",
+ "updates:\n",
+ " # Update to newer version of GitHub Actions\n",
+ " - package-ecosystem: \"github-actions\"\n",
+ " directory: \"/\"\n",
+ " schedule:\n",
+ " interval: \"weekly\"\n",
+ "\n",
+ " # Update to newer NuGet dependencies\n",
+ " - package-ecosystem: \"nuget\"\n",
+ " directory: \"/\"\n",
+ " schedule:\n",
+ " interval: \"daily\"\n",
+ "```\n",
+ "\n",
+ "This will automatically create a new PR when there is an update to the `fsdocs` tool.\n",
+ "\n",
+ "⚠️ P️lease be very careful, if you have followed along, we don\u0027t have any GitHub Actions right now that run against pull requests!\n",
+ "It is recommended to have an Action that builds your documentation against any incoming changes.\n",
+ "You typically want to lint code, run unit tests and perform other useful checks as well!\n",
+ "\n",
+ "Example Action, `.github/workflows/ci.yml`:\n",
+ "\n",
+ "```yml\n",
+ "name: CI\n",
+ "\n",
+ "on: [pull_request]\n",
+ "\n",
+ "jobs:\n",
+ " build:\n",
+ " runs-on: ubuntu-latest\n",
+ "\n",
+ " steps:\n",
+ " - uses: actions/checkout@v3\n",
+ " - name: Setup .NET Core\n",
+ " uses: actions/setup-dotnet@v3\n",
+ " - name: Restore tools\n",
+ " run: dotnet tool restore\n",
+ " - name: Build\n",
+ " run: dotnet build YourSolution.sln\n",
+ " - name: Documentation\n",
+ " run: dotnet fsdocs build\n",
+ "```\n",
+ "\n",
+ "⚠️ Also never trust any update to `fsdocs` blindly, always check the [release notes](https://github.com/fsprojects/FSharp.Formatting/blob/main/RELEASE_NOTES.md) to see if there are any breaking changes.\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": ".NET (F#)",
+ "language": "F#",
+ "name": ".net-fsharp"
+ },
+ "language_info": {
+ "file_extension": ".fs",
+ "mimetype": "text/x-fsharp",
+ "name": "polyglot-notebook",
+ "pygments_lexer": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelInfo": {
+ "defaultKernelName": "fsharp",
+ "items": [
+ {
+ "aliases": [],
+ "languageName": "fsharp",
+ "name": "fsharp"
+ }
+ ]
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+
diff --git a/zero-to-hero.md b/zero-to-hero.md
new file mode 100644
index 000000000..d711fd7bd
--- /dev/null
+++ b/zero-to-hero.md
@@ -0,0 +1,265 @@
+# Getting Started
+
+## From zero to hero: deploying to GitHub Pages
+
+This guide is meant for a typical setup of open-source projects on GitHub.
+We start from a repository without any documentation and aim to end up with a published website on [GitHub Pages](https://pages.github.com/).
+
+## Install the local tool
+
+If you don't have a [dotnet tool manifest](https://learn.microsoft.com/en-us/dotnet/core/tools/local-tools-how-to-use#create-a-manifest-file), you can create one using `dotnet new tool-manifest`.
+
+Next, we can install [fsdocs-tool](https://www.nuget.org/packages/fsdocs-tool/) using `dotnet tool install --local fsdocs-tool`.
+It is recommended to install this tool as a local tool because it allows us to update to newer versions of the tool at our own pace.
+
+## Create the docs folder
+
+After we've installed the tool, we can run `dotnet fsdocs --help` and see the available commands.
+Both `build` and `watch` will generate the documentation for a solution and an input folder.
+The default folder for `--input` is the `./docs` folder, relative to the current working directory.
+
+Typically your project will be structured like:
+
+```
+/repository-root
+ YourSolution.sln
+ ./docs
+ index.md
+ other-file.md
+ ./src
+ ./Project1/Project1.fsproj
+ ./Project2/Project2.fsproj
+```
+
+It is recommended to have a single solution at the root. In some editors, it is more convenient to open a solution at the root, to easily manipulate any file in root repository folder.
+When users clone your repository locally, they cannot be confused on how they need to open the project in their IDE.
+
+⚠️ Please avoid putting your solution in the `src` folder. When we open that solution, it can be more difficult to edit files in the `docs` folder, as we can sometimes only see the `src` folder.
+
+That being said, let's create the `docs` folder and a first Markdown file named `index.md`.
+When `fsdocs` runs, it will transform this `index.md` file to `index.html`, which will be served at the root.
+
+We can put `# Hello world` in the markdown file for now.
+
+Having this in place, should already serve the first page when we start the `watch` command:
+
+> dotnet fsdocs watch
+>
+
+Open [[http://localhost:8901](http://localhost:8901)](http://localhost:8901) and you should see our first page!
+
+🪄 You might notice that there are some images missing. You can add these in the `docs` folder in the right location.
+
+## Generating API documentation
+
+By default, `fsdocs` will generate API documentation for the configured `--projects`.
+When this flag is not specified, `fsdocs` will look for solutions or projects in the working directory.
+It will filter these found projects, the requirements are:
+
+* Having `library`
+
+* Having a binary, so you need to build your project first before the documentation can be generated.
+
+* Not having `true`
+
+* Having `true`
+
+🪄 If you made some changes in order to adhere to the rules, you may want to remove the `.fsdocs/cache` file.
+
+## Adding the missing properties
+
+After our initial `watch` run, you may have noticed that some links aren't working yet.
+`License`, `Releases Notes` and `Source Repository` can be provided by setting MSBuild properties.
+
+You can either add these properties to a single `.fsproj` file, or more typically, add them to a [Directory.Build.props](https://learn.microsoft.com/visualstudio/msbuild/customize-by-directory) file.
+The simplest `Directory.Build.props` file:
+
+```xml
+
+
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md
+ https://fsprojects.github.io/FSharp.AWS.DynamoDB
+
+
+```
+
+🪄 If you don't have any release notes yet, you could consider using [Ionide.KeepAChangelog](https://github.com/ionide/KeepAChangelog).
+
+Running `dotnet fsdocs watch` will now yield:
+
+```
+ root --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/
+ ...
+ fsdocs-license-link --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md
+ fsdocs-release-notes-link --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md
+ ...
+ fsdocs-repository-link --> https://github.com/fsprojects/FSharp.AWS.DynamoDB/
+```
+
+⚠️ Again, you might need to remove `.fsdocs/cache` in order for changes to be picked up!
+
+`` is actually a very important property when you run `dotnet fsdocs build`.
+`build` will generate static files for the targeted production environment. In our case, this will be GitHub Pages.
+
+Pages will host your files from [https://github.com/user/project](https://github.com/user/project) on `https://user.github.io/project/` by default.
+You can change this by adding a custom domain so we need to be sure that all links and urls will be generated correctly during a build.
+
+Let's now run `dotnet fsdocs build`.
+
+`` will replace the `{{root}}` substitution, which is used all over the place in the default template.
+
+⚠️ You want to ensure that the static files in the `output` folder (after running the build) have the correct links.
+
+## Ignore generated files
+
+Alright, at this point we've made a lot of progress. If you are using `git` you want to add the following to your [.gitignore](https://git-scm.com/docs/gitignore) file.
+
+```.ignorelang
+# FSharp.Formatting
+.fsdocs/
+output/
+tmp/
+```
+
+## Ship it!
+
+Once we are satisfied with our documentation, we want to publish it to GitHub Pages.
+We can use [GitHub Actions](https://github.com/features/actions) to deploy our website.
+
+Deploy to Pages from GitHub Actions must be enabled in the repository settings:
+
+
+
+The typical flow is to publish your documentation after a release or after new commits were added to the default branch.
+Let's create a very basic Action that will deploy our website after pushing to main:
+
+Create a file `.github/workflows/docs.yml`:
+
+```yml
+name: Docs
+
+# Trigger this Action when new code is pushed to the main branch
+on:
+ push:
+ branches:
+ - main
+
+# We need some permissions to publish to Github Pages
+permissions:
+ contents: write
+ pages: write
+ id-token: write
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ # Checkout the source code
+ - uses: actions/checkout@v4
+ # Setup dotnet, please use a global.json to ensure the right SDK is used!
+ - name: Setup .NET
+ uses: actions/setup-dotnet@v3
+ # Restore the local tools
+ - name: Restore tools
+ run: dotnet tool restore
+ # Build the code for the API documentation
+ - name: Build code
+ run: dotnet build -c Release YourSolution.sln
+ # Generate the documentation files
+ - name: Generate the documentation'
+ run: dotnet fsdocs build --properties Configuration=Release
+ # Upload the static files
+ - name: Upload documentation
+ uses: actions/upload-pages-artifact@v2
+ with:
+ path: ./output
+
+ # GitHub Actions recommends deploying in a separate job.
+ deploy:
+ runs-on: ubuntu-latest
+ needs: build
+ steps:
+ - name: Deploy to GitHub Pages
+ id: deployment
+ uses: actions/deploy-pages@v2
+```
+
+⚠️ Careful yaml is indentation sensitive!
+
+## Next steps
+
+Mission accomplished, right? If everything went well, you should have a published website at this point!
+Here are some next steps you could consider:
+
+### Use fsx file in your documentation
+
+Create documentation using [Literate Scripts](../literate.html). A typical flow here is that you load your locate project binary into a script and create examples using the latest code:
+
+```fsharp
+#r "../src/Project1/bin/Debug/net6.0/Project1.dll"
+
+open Project1
+
+// Actual consumption of your project!
+let result = SomeType.SomeMethod("foo")
+```
+
+When using the `--strict` flag in `dotnet fsdocs build`, your documentation generation will fail if your script contains errors.
+This is useful to ensure your documentation is always in sync with your latest public API!
+
+### Automatically update to newer versions of fsdocs-tool
+
+Using [Dependabot](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/about-dependabot-version-updates) you can easily receive new PR's with updates to your `dotnet` dependencies.
+
+Create a `.github/dependabot.yml` file with:
+
+```yml
+version: 2
+updates:
+ # Update to newer version of GitHub Actions
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+
+ # Update to newer NuGet dependencies
+ - package-ecosystem: "nuget"
+ directory: "/"
+ schedule:
+ interval: "daily"
+```
+
+This will automatically create a new PR when there is an update to the `fsdocs` tool.
+
+⚠️ P️lease be very careful, if you have followed along, we don't have any GitHub Actions right now that run against pull requests!
+It is recommended to have an Action that builds your documentation against any incoming changes.
+You typically want to lint code, run unit tests and perform other useful checks as well!
+
+Example Action, `.github/workflows/ci.yml`:
+
+```yml
+name: CI
+
+on: [pull_request]
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v3
+ - name: Setup .NET Core
+ uses: actions/setup-dotnet@v3
+ - name: Restore tools
+ run: dotnet tool restore
+ - name: Build
+ run: dotnet build YourSolution.sln
+ - name: Documentation
+ run: dotnet fsdocs build
+```
+
+⚠️ Also never trust any update to `fsdocs` blindly, always check the [release notes](https://github.com/fsprojects/FSharp.Formatting/blob/main/RELEASE_NOTES.md) to see if there are any breaking changes.
+
+
diff --git a/zero-to-hero.tex b/zero-to-hero.tex
new file mode 100644
index 000000000..590a06ce8
--- /dev/null
+++ b/zero-to-hero.tex
@@ -0,0 +1,392 @@
+\documentclass{article}
+
+\usepackage{xcolor}
+\usepackage{graphicx}
+\usepackage{fancyvrb}
+\usepackage{listings}
+\usepackage[T1]{fontenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+
+\definecolor{officegreen}{rgb}{0, 0.5, 0}
+\definecolor{navy}{rgb}{0, 0, 0.5}
+\definecolor{linecolor}{rgb}{0.5, 0.6875, 0.6875}
+\definecolor{outputcolor}{rgb}{0.375, 0.375, 0.375}
+
+\newcommand{\id}[1]{\textcolor{black}{#1}}
+\newcommand{\com}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\inact}[1]{\textcolor{gray}{#1}}
+\newcommand{\kwd}[1]{\textcolor{navy}{#1}}
+\newcommand{\num}[1]{\textcolor{officegreen}{#1}}
+\newcommand{\ops}[1]{\textcolor{purple}{#1}}
+\newcommand{\prep}[1]{\textcolor{purple}{#1}}
+\newcommand{\str}[1]{\textcolor{olive}{#1}}
+\newcommand{\lines}[1]{\textcolor{linecolor}{#1}}
+\newcommand{\fsi}[1]{\textcolor{outputcolor}{#1}}
+\newcommand{\omi}[1]{\textcolor{gray}{#1}}
+
+% Overriding color and style of line numbers
+\renewcommand{\theFancyVerbLine}{
+\lines{\small \arabic{FancyVerbLine}:}}
+
+\lstset{%
+ backgroundcolor=\color{gray!15},
+ basicstyle=\ttfamily,
+ breaklines=true,
+ columns=fullflexible
+}
+
+\title{{page-title}}
+\date{}
+
+\begin{document}
+
+\maketitle
+
+
+\section*{Getting Started}
+
+\subsection*{From zero to hero: deploying to GitHub Pages}
+
+
+
+This guide is meant for a typical setup of open-source projects on GitHub.
+
+We start from a repository without any documentation and aim to end up with a published website on \href{https://pages.github.com/}{GitHub Pages}.
+\subsection*{Install the local tool}
+
+
+
+If you don't have a \href{https://learn.microsoft.com/en-us/dotnet/core/tools/local-tools-how-to-use\#create-a-manifest-file}{dotnet tool manifest}, you can create one using \texttt{dotnet new tool-manifest}.
+
+
+Next, we can install \href{https://www.nuget.org/packages/fsdocs-tool/}{fsdocs-tool} using \texttt{dotnet tool install --local fsdocs-tool}.
+
+It is recommended to install this tool as a local tool because it allows us to update to newer versions of the tool at our own pace.
+\subsection*{Create the docs folder}
+
+
+
+After we've installed the tool, we can run \texttt{dotnet fsdocs --help} and see the available commands.
+
+Both \texttt{build} and \texttt{watch} will generate the documentation for a solution and an input folder.
+
+The default folder for \texttt{--input} is the \texttt{./docs} folder, relative to the current working directory.
+
+
+Typically your project will be structured like:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\ops{/}\id{repository}\ops{-}\id{root}
+ \id{YourSolution}{.}\id{sln}
+ {.}\ops{/}\id{docs}
+ \id{index}{.}\id{md}
+ \id{other}\ops{-}\id{file}{.}\id{md}
+ {.}\ops{/}\id{src}
+ {.}\ops{/}\id{Project1}\ops{/}\id{Project1}{.}\id{fsproj}
+ {.}\ops{/}\id{Project2}\ops{/}\id{Project2}{.}\id{fsproj}
+
+
+\end{lstlisting}
+
+
+
+It is recommended to have a single solution at the root. In some editors, it is more convenient to open a solution at the root, to easily manipulate any file in root repository folder.
+
+When users clone your repository locally, they cannot be confused on how they need to open the project in their IDE.
+
+
+⚠️ Please avoid putting your solution in the \texttt{src} folder. When we open that solution, it can be more difficult to edit files in the \texttt{docs} folder, as we can sometimes only see the \texttt{src} folder.
+
+
+That being said, let's create the \texttt{docs} folder and a first Markdown file named \texttt{index.md}.
+
+When \texttt{fsdocs} runs, it will transform this \texttt{index.md} file to \texttt{index.html}, which will be served at the root.
+
+
+We can put \texttt{\# Hello world} in the markdown file for now.
+
+
+Having this in place, should already serve the first page when we start the \texttt{watch} command:
+\begin{quote}
+
+
+dotnet fsdocs watch
+\end{quote}
+
+
+
+Open \href{http://localhost:8901}{\href{http://localhost:8901}{http://localhost:8901}} and you should see our first page!
+
+
+🪄 You might notice that there are some images missing. You can add these in the \texttt{docs} folder in the right location.
+\subsection*{Generating API documentation}
+
+
+
+By default, \texttt{fsdocs} will generate API documentation for the configured \texttt{--projects}.
+
+When this flag is not specified, \texttt{fsdocs} will look for solutions or projects in the working directory.
+
+It will filter these found projects, the requirements are:
+\begin{itemize}
+\item Having \texttt{library}
+
+\item Having a binary, so you need to build your project first before the documentation can be generated.
+
+\item Not having \texttt{true}
+
+\item Having \texttt{true}
+
+\end{itemize}
+
+
+
+🪄 If you made some changes in order to adhere to the rules, you may want to remove the \texttt{.fsdocs/cache} file.
+\subsection*{Adding the missing properties}
+
+
+
+After our initial \texttt{watch} run, you may have noticed that some links aren't working yet.
+
+\texttt{License}, \texttt{Releases Notes} and \texttt{Source Repository} can be provided by setting MSBuild properties.
+
+
+You can either add these properties to a single \texttt{.fsproj} file, or more typically, add them to a \href{https://learn.microsoft.com/visualstudio/msbuild/customize-by-directory}{Directory.Build.props} file.
+
+The simplest \texttt{Directory.Build.props} file:
+\begin{lstlisting}
+
+
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md
+ https://github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE_NOTES.md
+ https://fsprojects.github.io/FSharp.AWS.DynamoDB
+
+
+
+\end{lstlisting}
+
+
+🪄 If you don't have any release notes yet, you could consider using \href{https://github.com/ionide/KeepAChangelog}{Ionide.KeepAChangelog}.
+
+
+Running \texttt{dotnet fsdocs watch} will now yield:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+ \id{root} \ops{-->} \id{https}{:}\com{//github.com/fsprojects/FSharp.AWS.DynamoDB/}
+ \ops{..}{.}
+ \id{fsdocs}\ops{-}\id{license}\ops{-}\id{link} \ops{-->} \id{https}{:}\com{//github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/License.md}
+ \id{fsdocs}\ops{-}\id{release}\ops{-}\id{notes}\ops{-}\id{link} \ops{-->} \id{https}{:}\com{//github.com/fsprojects/FSharp.AWS.DynamoDB/blob/master/RELEASE\_NOTES.md}
+ \ops{..}{.}
+ \id{fsdocs}\ops{-}\id{repository}\ops{-}\id{link} \ops{-->} \id{https}{:}\com{//github.com/fsprojects/FSharp.AWS.DynamoDB/}
+
+
+\end{lstlisting}
+
+
+
+⚠️ Again, you might need to remove \texttt{.fsdocs/cache} in order for changes to be picked up!
+
+
+\texttt{} is actually a very important property when you run \texttt{dotnet fsdocs build}.
+
+\texttt{build} will generate static files for the targeted production environment. In our case, this will be GitHub Pages.
+
+
+Pages will host your files from \href{https://github.com/user/project}{https://github.com/user/project} on \texttt{https://user.github.io/project/} by default.
+
+You can change this by adding a custom domain so we need to be sure that all links and urls will be generated correctly during a build.
+
+
+Let's now run \texttt{dotnet fsdocs build}.
+
+
+\texttt{} will replace the \texttt{\{\{root\}\}} substitution, which is used all over the place in the default template.
+
+
+⚠️ You want to ensure that the static files in the \texttt{output} folder (after running the build) have the correct links.
+\subsection*{Ignore generated files}
+
+
+
+Alright, at this point we've made a lot of progress. If you are using \texttt{git} you want to add the following to your \href{https://git-scm.com/docs/gitignore}{.gitignore} file.
+\begin{lstlisting}
+# FSharp.Formatting
+.fsdocs/
+output/
+tmp/
+
+\end{lstlisting}
+\subsection*{Ship it!}
+
+
+
+Once we are satisfied with our documentation, we want to publish it to GitHub Pages.
+We can use \href{https://github.com/features/actions}{GitHub Actions} to deploy our website.
+
+
+Deploy to Pages from GitHub Actions must be enabled in the repository settings:
+
+
+\begin{figure}[htbp]\centering
+\includegraphics[width=1.0\textwidth]{./content/img/github-pages-settings.png}
+\caption{Enable deploy from Actions}
+\end{figure}
+
+
+
+The typical flow is to publish your documentation after a release or after new commits were added to the default branch.
+
+Let's create a very basic Action that will deploy our website after pushing to main:
+
+
+Create a file \texttt{.github/workflows/docs.yml}:
+\begin{lstlisting}
+name: Docs
+
+# Trigger this Action when new code is pushed to the main branch
+on:
+ push:
+ branches:
+ - main
+
+# We need some permissions to publish to Github Pages
+permissions:
+ contents: write
+ pages: write
+ id-token: write
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ # Checkout the source code
+ - uses: actions/checkout@v4
+ # Setup dotnet, please use a global.json to ensure the right SDK is used!
+ - name: Setup .NET
+ uses: actions/setup-dotnet@v3
+ # Restore the local tools
+ - name: Restore tools
+ run: dotnet tool restore
+ # Build the code for the API documentation
+ - name: Build code
+ run: dotnet build -c Release YourSolution.sln
+ # Generate the documentation files
+ - name: Generate the documentation'
+ run: dotnet fsdocs build --properties Configuration=Release
+ # Upload the static files
+ - name: Upload documentation
+ uses: actions/upload-pages-artifact@v2
+ with:
+ path: ./output
+
+ # GitHub Actions recommends deploying in a separate job.
+ deploy:
+ runs-on: ubuntu-latest
+ needs: build
+ steps:
+ - name: Deploy to GitHub Pages
+ id: deployment
+ uses: actions/deploy-pages@v2
+
+\end{lstlisting}
+
+
+⚠️ Careful yaml is indentation sensitive!
+\subsection*{Next steps}
+
+
+
+Mission accomplished, right? If everything went well, you should have a published website at this point!
+
+Here are some next steps you could consider:
+\subsubsection*{Use fsx file in your documentation}
+
+
+
+Create documentation using \href{../literate.html}{Literate Scripts}. A typical flow here is that you load your locate project binary into a script and create examples using the latest code:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\prep{\#r} \str{"../src/Project1/bin/Debug/net6.0/Project1.dll"}
+
+\kwd{open} \id{Project1}
+
+\com{// Actual consumption of your project!}
+\kwd{let} \id{result} \ops{=} \id{SomeType}{.}\id{SomeMethod}{(}\str{"foo"}{)}
+
+
+\end{lstlisting}
+
+
+
+When using the \texttt{--strict} flag in \texttt{dotnet fsdocs build}, your documentation generation will fail if your script contains errors.
+
+This is useful to ensure your documentation is always in sync with your latest public API!
+\subsubsection*{Automatically update to newer versions of fsdocs-tool}
+
+
+
+Using \href{https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/about-dependabot-version-updates}{Dependabot} you can easily receive new PR's with updates to your \texttt{dotnet} dependencies.
+
+
+Create a \texttt{.github/dependabot.yml} file with:
+\begin{lstlisting}
+version: 2
+updates:
+ # Update to newer version of GitHub Actions
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+
+ # Update to newer NuGet dependencies
+ - package-ecosystem: "nuget"
+ directory: "/"
+ schedule:
+ interval: "daily"
+
+\end{lstlisting}
+
+
+This will automatically create a new PR when there is an update to the \texttt{fsdocs} tool.
+
+
+⚠️ P️lease be very careful, if you have followed along, we don't have any GitHub Actions right now that run against pull requests!
+
+It is recommended to have an Action that builds your documentation against any incoming changes.
+
+You typically want to lint code, run unit tests and perform other useful checks as well!
+
+
+Example Action, \texttt{.github/workflows/ci.yml}:
+\begin{lstlisting}
+name: CI
+
+on: [pull_request]
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v3
+ - name: Setup .NET Core
+ uses: actions/setup-dotnet@v3
+ - name: Restore tools
+ run: dotnet tool restore
+ - name: Build
+ run: dotnet build YourSolution.sln
+ - name: Documentation
+ run: dotnet fsdocs build
+
+\end{lstlisting}
+
+
+⚠️ Also never trust any update to \texttt{fsdocs} blindly, always check the \href{https://github.com/fsprojects/FSharp.Formatting/blob/main/RELEASE\_NOTES.md}{release notes} to see if there are any breaking changes.
+
+
+\end{document}
\ No newline at end of file
+ FSharp.Formatting
+ 
+
+
