* *
+
+* * *
+*
+
+```
+
+In addition, you may also use the [Recommended XML doc extensions for F# documentation tooling](https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md).
+
+* `` links
+
+
+* Arbitrary paragraph-level HTML such as `` for bold in XML doc text
+
+
+* `` giving documentation for the enclosing namespace
+
+
+* `` 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](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`:
+
+*)
+///
+/// A module
+///
+///
+///
+/// A namespace to remember
+///
+/// More on that
+///
+///
+module SomeModule =
+ ///
+ /// Some actual comment
+ /// Another paragraph, see
+ ///
+ ///
+ /// The input
+ ///
+ /// The output
+ ///
+ ///
+ /// Try using
+ ///
+ /// open TheNamespace
+ /// SomeModule.a
+ ///
+ ///
+ ///
+ /// Foo
+ let someFunction x = 42 + x
+
+///
+/// A type, see
+///
+type SomeType() =
+ member x.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:
+
+*)
+type Class2() =
+ member this.Property = "more"
+ member this.Method0() = "more"
+ member this.Method1(c: string) = "more"
+ member this.Method2(c: string, o: obj) = "more"
+
+/// ` to create cross-references.
+
+For example:
+
+*)
+module Forest =
+
+ ///
+ /// Find at most limit foxes in current forest
+ ///
+ /// See also:
+ let findFoxes (limit : int) = []
+
+ ///
+ /// Find at most limit squirrels in current forest
+ ///
+ /// See also:
+ let findSquirrels (limit : int) = []
+(**
+You can find the correct value for `cref` in the generated `.xml` documentation file (this will be generated alongside the assembly's `.dll``).
+
+You can also omit the `cref`'s arguments, and `fsdocs` will make an attempt to find the first member that matches.
+
+For example:
+
+```
+ /// See also: ` (for example, you may wish to hide existing documentation while it's in progress).
+The `
+/// BottleKids5 is all you'll ever need in terms of bottles or kids.
+///
+module BottleKids5 =
+ let a = 46
+(**
+Note that the comments for `BottleKids3` (and `BottleKids4`) will generate a warning. This is because
+the `` tags to remove
+the warning.
+
+The warning will be of the following format:
+
+```
+Warning: detected "" for "M:YourLib.BottleKids4". Please see https://fsprojects.github.io/FSharp.Formatting/apidocs.html#Classic-XML-Doc-Comments
+```
+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:
+
+```
+The use of `[omit]` 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
+```
+
+
+## Go to Source links
+
+'fsdocs' normally automatically adds GitHub links to each functions, values and class members for further reference.
+
+This is normally done automatically based on the following settings:
+
+```xml
+ https://github.com/...
+ ...
+ git
+```
+
+If your source is not built from the same project where you are building documentation then
+you may need these settings:
+
+```xml
+ ... -- the URL for the root of the source
+ ... -- the root soure folder at time of build
+```
+
+It is assumed that `sourceRepo` and `sourceFolder` have synchronized contents.
+
+## Markdown Comments
+
+You can use Markdown instead of XML in `///` comments. If you do, you should set `true ` in
+your F# project file.
+
+> Note: Markdown Comments are not supported in all F# IDE tooling.
+>
+
+### Adding cross-type links to modules and types in the same assembly
+
+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](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#links) 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](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#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]
+module Foo =
+
+ /// Bar is just an `int` and belongs to module [Foo]
+ type Bar = int
+
+ /// Baz contains a `Foo.Bar` as its `id`
+ type Baz = { id: Bar }
+
+ /// This function operates on `Baz` types.
+ let f (b: Baz) = b.id * 42
+
+/// Referencing [Foo3] will not generate a link as there is no type with the name `Foo3`
+module Foo3 =
+
+ /// This is not the same type as `Foo.Bar`
+ type Bar = 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.
+ let f2 b = b * 50
+(**
+### Markdown Comments: Excluding APIs from the docs
+
+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]
+module Bar =
+ let a = 42
+(**
+Example as first line:
+
+*)
+/// [omit]
+/// Some actual comment
+module Bar2 =
+ let a = 42
+(**
+## Building library documentation programmatically
+
+You can build library documentation programatically using the functionality
+in the [ApiDocs](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html) type. To do this, load the assembly and open necessary namespaces:
+
+*)
+#r "FSharp.Formatting.ApiDocs.dll"
+
+open FSharp.Formatting.ApiDocs
+open System.IO
+(**
+For example the [ApiDocs.GenerateHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#GenerateHtml) method:
+
+*)
+let file = Path.Combine(root, "bin/YourLibrary.dll")
+
+let input = ApiDocInput.FromFile(file)
+
+ApiDocs.GenerateHtml(
+ [ input ],
+ output = Path.Combine(root, "output"),
+ collectionName = "YourLibrary",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = []
+)
+(**
+### Adding extra dependencies
+
+When building a library programmatically, you might require a reference to an additional assembly.
+You can pass this using the `otherFlags` argument.
+
+*)
+let projectAssembly = Path.Combine(root, "bin/X.dll")
+
+let projectInput = ApiDocInput.FromFile(projectAssembly)
+
+ApiDocs.GenerateHtml(
+ [ projectInput ],
+ output = Path.Combine(root, "output"),
+ collectionName = "Project X",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = [],
+ otherFlags = [ "-r:/root/ProjectY/bin/Debug/net6.0/Y.dll" ]
+)
+(**
+or use `libDirs` to include all assemblies from an entire folder.
+Tip: A combination of `true ` 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.
+
+*)
+ApiDocs.GenerateHtml(
+ [ projectInput ],
+ output = Path.Combine(root, "output"),
+ collectionName = "Project X",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = [],
+ libDirs = [ "ProjectX/bin/Debug/netstandard2.0" ]
+)
+(**
+## Rebasing Links
+
+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 `` 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 Generating API Docs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+API Documentation Generation
+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.
+Selected projects
+fsdocs automatically selects the projects and "cracks" the project files for information
+
+- Projects with
GenerateDocumentationFile and without IsTestProject are selected.
+- Projects must not use
TargetFrameworks (only TargetFramework, singular).
+
+ <PropertyGroup>
+ <GenerateDocumentationFile>true</GenerateDocumentationFile>
+ </PropertyGroup>
+
+Templates
+The HTML is built by instantiating a template. The template used is the first of:
+
+docs/reference/_template.html
docs/_template.html
- The default template
+
+Usually the same template can be used as for other content.
+Classic XML Doc Comments
+XML Doc Comments may use the normal F# and C# XML doc standards.
+The tags that form the core of the XML doc specification are:
+<c> <para> <see>* <value>
+<code> <param>* <seealso>*
+<example> <paramref> <summary>
+<exception>* <permission>* <typeparam>*
+<include>* <remarks> <typeparamref>
+<list> <inheritdoc> <returns>
+
+In addition, you may also use the Recommended XML doc extensions for F# documentation tooling.
+
+<a href = "..."> links
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>
+///
+module SomeModule =
+ /// <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>
+ let someFunction x = 42 + x
+
+/// <summary>
+/// A type, see <see cref="T:TheNamespace.SomeModule"/> and
+/// <see cref="M:TheNamespace.SomeModule.someFunction"/>.
+/// </summary>
+///
+type SomeType() =
+ member x.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:
+type Class2() =
+ member this.Property = "more"
+ member this.Method0() = "more"
+ member this.Method1(c: string) = "more"
+ member this.Method2(c: string, o: obj) = "more"
+
+/// <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)" />
+let referringFunction1 () = "result"
+
+Generic types are referred to by .NET compiled name, e.g.
+type GenericClass2<'T>() =
+ member this.Property = "more"
+
+ member this.NonGenericMethod(_c: 'T) = "more"
+
+ member this.GenericMethod(_c: 'T, _o: 'U) = "more"
+
+/// 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)" />
+let referringFunction2 () = "result"
+
+Cross-referencing with <seealso>
+Use <seealso cref="..."/> within <summary> to create cross-references.
+For example:
+module Forest =
+
+ /// <summary>
+ /// Find at most <c>limit</c> foxes in current forest
+ ///
+ /// See also: <seealso cref="M:App.Forest.findSquirrels(System.Int32)"/>
+ /// </summary>
+ let findFoxes (limit : int) = []
+
+ /// <summary>
+ /// Find at most <c>limit</c> squirrels in current forest
+ ///
+ /// See also: <seealso cref="M:App.Forest.findFoxes(System.Int32)"/>
+ /// </summary>
+ let findSquirrels (limit : int) = []
+
+You can find the correct value for cref in the generated .xml documentation file (this will be generated alongside the assembly's .dll`).
+You can also omit the cref's arguments, and fsdocs will make an attempt to find the first member that matches.
+For example:
+ /// See also: <seealso cref="M:App.Forest.findSquirrels"/>
+
+If the member cannot be found, a link to the containing module/type will be used instead.
+Classic XMl Doc Comments: Excluding APIs from the docs
+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/>
+module BottleKids1 =
+ let a = 42
+
+// Ordinary comment
+/// <exclude/>
+module BottleKids2 =
+ let a = 43
+
+/// <exclude/>
+/// BottleKids3 provides improvements over BottleKids2
+module BottleKids3 =
+ let a = 44
+
+/// BottleKids4 implements several new features over BottleKids3
+/// <exclude/>
+module BottleKids4 =
+ let a = 45
+
+/// <exclude/>
+/// <summary>
+/// BottleKids5 is all you'll ever need in terms of bottles or kids.
+/// </summary>
+module BottleKids5 =
+ let a = 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.
+The warning will be of the following format:
+Warning: detected "<exclude/>" in text of "<summary>" for "M:YourLib.BottleKids4". Please see https://fsprojects.github.io/FSharp.Formatting/apidocs.html#Classic-XML-Doc-Comments
+
+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:
+The use of `[omit]` 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
+
+Go to Source links
+'fsdocs' normally automatically adds GitHub links to each functions, values and class members for further reference.
+This is normally done automatically based on the following settings:
+ <RepositoryUrl>https://github.com/...</RepositoryUrl>
+ <RepositoryBranch>...</RepositoryBranch>
+ <RepositoryType>git</RepositoryType>
+
+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.
+Markdown Comments
+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.
+
+Adding cross-type links to modules and types in the same assembly
+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]
+module Foo =
+
+ /// Bar is just an `int` and belongs to module [Foo]
+ type Bar = int
+
+ /// Baz contains a `Foo.Bar` as its `id`
+ type Baz = { id: Bar }
+
+ /// This function operates on `Baz` types.
+ let f (b: Baz) = b.id * 42
+
+/// Referencing [Foo3] will not generate a link as there is no type with the name `Foo3`
+module Foo3 =
+
+ /// This is not the same type as `Foo.Bar`
+ type Bar = 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.
+ let f2 b = b * 50
+
+Markdown Comments: Excluding APIs from the docs
+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]
+module Bar =
+ let a = 42
+
+Example as first line:
+/// [omit]
+/// Some actual comment
+module Bar2 =
+ let a = 42
+
+Building library documentation programmatically
+You can build library documentation programatically using the functionality
+in the ApiDocs type. To do this, load the assembly and open necessary namespaces:
+#r "FSharp.Formatting.ApiDocs.dll"
+
+open FSharp.Formatting.ApiDocs
+open System.IO
+
+For example the ApiDocs.GenerateHtml method:
+let file = Path.Combine(root, "bin/YourLibrary.dll")
+
+let input = ApiDocInput.FromFile(file)
+
+ApiDocs.GenerateHtml(
+ [ input ],
+ output = Path.Combine(root, "output"),
+ collectionName = "YourLibrary",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = []
+)
+
+Adding extra dependencies
+When building a library programmatically, you might require a reference to an additional assembly.
+You can pass this using the otherFlags argument.
+let projectAssembly = Path.Combine(root, "bin/X.dll")
+
+let projectInput = ApiDocInput.FromFile(projectAssembly)
+
+ApiDocs.GenerateHtml(
+ [ projectInput ],
+ output = Path.Combine(root, "output"),
+ collectionName = "Project X",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = [],
+ otherFlags = [ "-r:/root/ProjectY/bin/Debug/net6.0/Y.dll" ]
+)
+
+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.
+ApiDocs.GenerateHtml(
+ [ projectInput ],
+ output = Path.Combine(root, "output"),
+ collectionName = "Project X",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = [],
+ libDirs = [ "ProjectX/bin/Debug/netstandard2.0" ]
+)
+
+Rebasing Links
+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>.
+For example:
+dotnet fsdocs build --output public/docs --parameters root ../
+
+
+ val root: string
+type 'T list = List<'T>
+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`
+Baz.id: Bar
+val f: b: Baz -> Bar
This function operates on `Baz` types.
+val b: Baz
+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>
+Path.Combine([<System.ParamArray>] paths: string array) : string
Path.Combine(path1: string, path2: string) : string
Path.Combine(path1: string, path2: string, path3: string) : string
Path.Combine(path1: string, path2: string, path3: string, path4: string) : string
+val input: ApiDocInput
+type ApiDocInput =
+ {
+ Path: string
+ XmlFile: string option
+ SourceFolder: string option
+ SourceRepo: string option
+ Substitutions: Substitutions option
+ MarkdownComments: bool
+ Warn: bool
+ PublicOnly: bool
+ }
+ static member FromFile: assemblyPath: string * ?mdcomments: bool * ?substitutions: Substitutions * ?sourceRepo: string * ?sourceFolder: string * ?publicOnly: bool * ?warn: bool -> ApiDocInput
<summary>
+ Represents an input assembly for API doc generation
+</summary>
+static member ApiDocInput.FromFile: assemblyPath: string * ?mdcomments: bool * ?substitutions: FSharp.Formatting.Templating.Substitutions * ?sourceRepo: string * ?sourceFolder: string * ?publicOnly: bool * ?warn: bool -> ApiDocInput
+type ApiDocs =
+ static member GenerateHtml: inputs: ApiDocInput list * output: string * collectionName: string * substitutions: Substitutions * ?template: string * ?root: string * ?qualify: bool * ?libDirs: string list * ?otherFlags: string list * ?urlRangeHighlight: (Uri -> int -> int -> string) * ?onError: (string -> unit) -> ApiDocModel * ApiDocsSearchIndexEntry array
+ static member GenerateMarkdown: inputs: ApiDocInput list * output: string * collectionName: string * substitutions: Substitutions * ?template: string * ?root: string * ?qualify: bool * ?libDirs: string list * ?otherFlags: string list * ?urlRangeHighlight: (Uri -> int -> int -> string) * ?onError: (string -> unit) -> ApiDocModel * ApiDocsSearchIndexEntry array
+ static member GenerateModel: inputs: ApiDocInput list * collectionName: string * substitutions: Substitutions * ?qualify: bool * ?libDirs: string list * ?otherFlags: string list * ?root: string * ?urlRangeHighlight: (Uri -> int -> int -> string) * ?onError: (string -> unit) * ?extension: ApiDocFileExtensions -> ApiDocModel
+ static member SearchIndexEntriesForModel: model: ApiDocModel -> ApiDocsSearchIndexEntry array
<summary>
+ 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.
+ </summary>
<namespacedoc><summary>Functionality relating to generating API documentation</summary></namespacedoc>
+static member ApiDocs.GenerateHtml: inputs: ApiDocInput list * output: string * collectionName: string * substitutions: FSharp.Formatting.Templating.Substitutions * ?template: string * ?root: string * ?qualify: bool * ?libDirs: string list * ?otherFlags: string list * ?urlRangeHighlight: (System.Uri -> int -> int -> string) * ?onError: (string -> unit) -> ApiDocModel * ApiDocsSearchIndexEntry array
+val projectAssembly: string
+val projectInput: ApiDocInput
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/apidocs.ipynb b/apidocs.ipynb
new file mode 100644
index 000000000..a1059b6d6
--- /dev/null
+++ b/apidocs.ipynb
@@ -0,0 +1,726 @@
+
+{
+ "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,19.1.1\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=apidocs.ipynb)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//apidocs.fsx)\u0026emsp;\n",
+ "[](https://fsprojects.github.io/FSharp.Formatting//apidocs.ipynb)\n",
+ "\n",
+ "# API Documentation Generation\n",
+ "\n",
+ "The [command-line tool `fsdocs`](commandline.html) can be used to generate documentation\n",
+ "for F# libraries with XML comments. The documentation is normally built using `fsdocs build` and developed using `fsdocs watch`. For\n",
+ "the former the output will be placed in `output\\reference` by default.\n",
+ "\n",
+ "## Selected projects\n",
+ "\n",
+ "`fsdocs` automatically selects the projects and \"cracks\" the project files for information\n",
+ "\n",
+ "* Projects with `GenerateDocumentationFile` and without `IsTestProject` are selected.\n",
+ "\n",
+ "* Projects must not use `TargetFrameworks` (only `TargetFramework`, singular).\n",
+ "\n",
+ "```text\n",
+ " \u003cPropertyGroup\u003e\n",
+ " \u003cGenerateDocumentationFile\u003etrue\u003c/GenerateDocumentationFile\u003e\n",
+ " \u003c/PropertyGroup\u003e\n",
+ "```\n",
+ "\n",
+ "## Templates\n",
+ "\n",
+ "The HTML is built by instantiating a template. The template used is the first of:\n",
+ "\n",
+ "* `docs/reference/_template.html`\n",
+ " \n",
+ "\n",
+ "* `docs/_template.html`\n",
+ " \n",
+ "\n",
+ "* The default template\n",
+ " \n",
+ "\n",
+ "Usually the same template can be used as for [other content](content.html).\n",
+ "\n",
+ "## Classic XML Doc Comments\n",
+ "\n",
+ "XML Doc Comments may use [the normal F# and C# XML doc standards](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/xmldoc/).\n",
+ "\n",
+ "The tags that form the core of the XML doc specification are:\n",
+ "\n",
+ "```\n",
+ "\u003cc\u003e\t\u003cpara\u003e\t\u003csee\u003e*\t\u003cvalue\u003e\n",
+ "\u003ccode\u003e\t\u003cparam\u003e*\t\u003cseealso\u003e*\n",
+ "\u003cexample\u003e\t\u003cparamref\u003e\t\u003csummary\u003e\n",
+ "\u003cexception\u003e*\t\u003cpermission\u003e*\t\u003ctypeparam\u003e*\n",
+ "\u003cinclude\u003e*\t\u003cremarks\u003e\t\u003ctypeparamref\u003e\n",
+ "\u003clist\u003e\t\u003cinheritdoc\u003e\t\u003creturns\u003e\n",
+ "```\n",
+ "\n",
+ "In addition, you may also use the [Recommended XML doc extensions for F# documentation tooling](https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md).\n",
+ "\n",
+ "* `\u003ca href = \"...\"\u003e` links\n",
+ " \n",
+ "\n",
+ "* Arbitrary paragraph-level HTML such as `\u003cb\u003e` for bold in XML doc text\n",
+ " \n",
+ "\n",
+ "* `\u003cnamespacedoc\u003e` giving documentation for the enclosing namespace\n",
+ " \n",
+ "\n",
+ "* `\u003cexclude/\u003e` to exclude from XML docs\n",
+ " \n",
+ "\n",
+ "* `\u003ccategory\u003e` to give a category for an entity or member. An optional `index` attribute can be specified\n",
+ "to help sort the list of categories.\n",
+ " \n",
+ "\n",
+ "* `\\(...\\)` for inline math and `$$...$$` and `\\[...\\]`for math environments, see [http://docs.mathjax.org.\n",
+ "Some](http://docs.mathjax.org.\n",
+ "Some) escaping of characters (e.g. `\u0026lt;`, `\u0026gt;`) may be needed to form valid XML\n",
+ " \n",
+ "\n",
+ "An example of an XML documentation comment, assuming the code is in namespace `TheNamespace`:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// \u003csummary\u003e\n",
+ "/// A module\n",
+ "/// \u003c/summary\u003e\n",
+ "///\n",
+ "/// \u003cnamespacedoc\u003e\n",
+ "/// \u003csummary\u003eA namespace to remember\u003c/summary\u003e\n",
+ "///\n",
+ "/// \u003cremarks\u003eMore on that\u003c/remarks\u003e\n",
+ "/// \u003c/namespacedoc\u003e\n",
+ "///\n",
+ "module SomeModule =\n",
+ " /// \u003csummary\u003e\n",
+ " /// Some actual comment\n",
+ " /// \u003cpara\u003eAnother paragraph, see \u003csee cref=\"T:TheNamespace.SomeType\"/\u003e. \u003c/para\u003e\n",
+ " /// \u003c/summary\u003e\n",
+ " ///\n",
+ " /// \u003cparam name=\"x\"\u003eThe input\u003c/param\u003e\n",
+ " ///\n",
+ " /// \u003creturns\u003eThe output\u003c/returns\u003e\n",
+ " ///\n",
+ " /// \u003cexample\u003e\n",
+ " /// Try using\n",
+ " /// \u003ccode\u003e\n",
+ " /// open TheNamespace\n",
+ " /// SomeModule.a\n",
+ " /// \u003c/code\u003e\n",
+ " /// \u003c/example\u003e\n",
+ " ///\n",
+ " /// \u003ccategory\u003eFoo\u003c/category\u003e\n",
+ " let someFunction x = 42 + x\n",
+ "\n",
+ "/// \u003csummary\u003e\n",
+ "/// A type, see \u003csee cref=\"T:TheNamespace.SomeModule\"/\u003e and\n",
+ "/// \u003csee cref=\"M:TheNamespace.SomeModule.someFunction\"/\u003e.\n",
+ "/// \u003c/summary\u003e\n",
+ "///\n",
+ "type SomeType() =\n",
+ " member x.P = 1\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "Like types, members are referred to by xml doc sig. These must currently be precise as the F#\n",
+ "compiler doesn\u0027t elaborate these references from simpler names:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "type Class2() =\n",
+ " member this.Property = \"more\"\n",
+ " member this.Method0() = \"more\"\n",
+ " member this.Method1(c: string) = \"more\"\n",
+ " member this.Method2(c: string, o: obj) = \"more\"\n",
+ "\n",
+ "/// \u003csee cref=\"P:TheNamespace.Class2.Property\" /\u003e\n",
+ "/// and \u003csee cref=\"M:TheNamespace.Class2.OtherMethod0\" /\u003e\n",
+ "/// and \u003csee cref=\"M:TheNamespace.Class2.Method1(System.String)\" /\u003e\n",
+ "/// and \u003csee cref=\"M:TheNamespace.Class2.Method2(System.String,System.Object)\" /\u003e\n",
+ "let referringFunction1 () = \"result\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "Generic types are referred to by .NET compiled name, e.g.\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "type GenericClass2\u003c\u0027T\u003e() =\n",
+ " member this.Property = \"more\"\n",
+ "\n",
+ " member this.NonGenericMethod(_c: \u0027T) = \"more\"\n",
+ "\n",
+ " member this.GenericMethod(_c: \u0027T, _o: \u0027U) = \"more\"\n",
+ "\n",
+ "/// See \u003csee cref=\"T:TheNamespace.GenericClass2`1\" /\u003e\n",
+ "/// and \u003csee cref=\"P:TheNamespace.GenericClass2`1.Property\" /\u003e\n",
+ "/// and \u003csee cref=\"M:TheNamespace.GenericClass2`1.NonGenericMethod(`0)\" /\u003e\n",
+ "/// and \u003csee cref=\"M:TheNamespace.GenericClass2`1.GenericMethod``1(`0,``0)\" /\u003e\n",
+ "let referringFunction2 () = \"result\"\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "### Cross-referencing with \u0026lt;seealso\u0026gt;\n",
+ "\n",
+ "Use `\u003cseealso cref=\"...\"/\u003e` within `\u003csummary\u003e` to create cross-references.\n",
+ "\n",
+ "For example:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "module Forest =\n",
+ "\n",
+ " /// \u003csummary\u003e\n",
+ " /// Find at most \u003cc\u003elimit\u003c/c\u003e foxes in current forest\n",
+ " ///\n",
+ " /// See also: \u003cseealso cref=\"M:App.Forest.findSquirrels(System.Int32)\"/\u003e\n",
+ " /// \u003c/summary\u003e\n",
+ " let findFoxes (limit : int) = []\n",
+ "\n",
+ " /// \u003csummary\u003e\n",
+ " /// Find at most \u003cc\u003elimit\u003c/c\u003e squirrels in current forest\n",
+ " ///\n",
+ " /// See also: \u003cseealso cref=\"M:App.Forest.findFoxes(System.Int32)\"/\u003e\n",
+ " /// \u003c/summary\u003e\n",
+ " let findSquirrels (limit : int) = []\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "You can find the correct value for `cref` in the generated `.xml` documentation file (this will be generated alongside the assembly\u0027s `.dll``).\n",
+ "\n",
+ "You can also omit the `cref`\u0027s arguments, and `fsdocs` will make an attempt to find the first member that matches.\n",
+ "\n",
+ "For example:\n",
+ "\n",
+ "```\n",
+ " /// See also: \u003cseealso cref=\"M:App.Forest.findSquirrels\"/\u003e\n",
+ "```\n",
+ "\n",
+ "If the member cannot be found, a link to the containing module/type will be used instead.\n",
+ "\n",
+ "### Classic XMl Doc Comments: Excluding APIs from the docs\n",
+ "\n",
+ "If you want to exclude modules or functions from the API docs you can use the `\u003cexclude/\u003e` tag.\n",
+ "It needs to be set on a separate triple-slashed line, and can either appear on its own or as part\n",
+ "of an existing `\u003csummary\u003e` (for example, you may wish to hide existing documentation while it\u0027s in progress).\n",
+ "The `\u003cexclude/\u003e` tag can be the first or last line in these cases.\n",
+ "\n",
+ "Some examples:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// \u003cexclude/\u003e\n",
+ "module BottleKids1 =\n",
+ " let a = 42\n",
+ "\n",
+ "// Ordinary comment\n",
+ "/// \u003cexclude/\u003e\n",
+ "module BottleKids2 =\n",
+ " let a = 43\n",
+ "\n",
+ "/// \u003cexclude/\u003e\n",
+ "/// BottleKids3 provides improvements over BottleKids2\n",
+ "module BottleKids3 =\n",
+ " let a = 44\n",
+ "\n",
+ "/// BottleKids4 implements several new features over BottleKids3\n",
+ "/// \u003cexclude/\u003e\n",
+ "module BottleKids4 =\n",
+ " let a = 45\n",
+ "\n",
+ "/// \u003cexclude/\u003e\n",
+ "/// \u003csummary\u003e\n",
+ "/// BottleKids5 is all you\u0027ll ever need in terms of bottles or kids.\n",
+ "/// \u003c/summary\u003e\n",
+ "module BottleKids5 =\n",
+ " let a = 46\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "Note that the comments for `BottleKids3` (and `BottleKids4`) will generate a warning. This is because\n",
+ "the `\u003cexclude/\u003e` tag will be parsed as part of the `summary` text, and so the documentation generator\n",
+ "can\u0027t be completely sure you meant to exclude the item, or whether it was a valid part of the documentation.\n",
+ "It will assume the exclusion was intended, but you may want to use explicit `\u003csummary\u003e` tags to remove\n",
+ "the warning.\n",
+ "\n",
+ "The warning will be of the following format:\n",
+ "\n",
+ "```\n",
+ "Warning: detected \"\u003cexclude/\u003e\" in text of \"\u003csummary\u003e\" for \"M:YourLib.BottleKids4\". Please see https://fsprojects.github.io/FSharp.Formatting/apidocs.html#Classic-XML-Doc-Comments\n",
+ "```\n",
+ "You will find that `[omit]` also works, but is considered part of the Markdown syntax and is\n",
+ "deprecated for XML Doc comments. This will also produce a warning, such as this:\n",
+ "\n",
+ "```\n",
+ "The use of `[omit]` 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",
+ "```\n",
+ "\n",
+ "\n",
+ "## Go to Source links\n",
+ "\n",
+ "\u0027fsdocs\u0027 normally automatically adds GitHub links to each functions, values and class members for further reference.\n",
+ "\n",
+ "This is normally done automatically based on the following settings:\n",
+ "\n",
+ "```xml\n",
+ " \u003cRepositoryUrl\u003ehttps://github.com/...\u003c/RepositoryUrl\u003e\n",
+ " \u003cRepositoryBranch\u003e...\u003c/RepositoryBranch\u003e\n",
+ " \u003cRepositoryType\u003egit\u003c/RepositoryType\u003e\n",
+ "```\n",
+ "\n",
+ "If your source is not built from the same project where you are building documentation then\n",
+ "you may need these settings:\n",
+ "\n",
+ "```xml\n",
+ " \u003cFsDocsSourceRepository\u003e...\u003c/FsDocsSourceRepository\u003e -- the URL for the root of the source\n",
+ " \u003cFsDocsSourceFolder\u003e...\u003c/FsDocsSourceFolder\u003e -- the root soure folder at time of build\n",
+ "```\n",
+ "\n",
+ "It is assumed that `sourceRepo` and `sourceFolder` have synchronized contents.\n",
+ "\n",
+ "## Markdown Comments\n",
+ "\n",
+ "You can use Markdown instead of XML in `///` comments. If you do, you should set `\u003cUsesMarkdownComments\u003etrue\u003c/UsesMarkdownComments\u003e` in\n",
+ "your F# project file.\n",
+ "\n",
+ "\u003e Note: Markdown Comments are not supported in all F# IDE tooling.\n",
+ "\u003e \n",
+ "\n",
+ "### Adding cross-type links to modules and types in the same assembly\n",
+ "\n",
+ "You can automatically add cross-type links to the documentation pages of other modules and types in the same assembly.\n",
+ "You can do this in two different ways:\n",
+ "\n",
+ "* Add a [markdown inline link](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#links) were the link\n",
+ "title is the name of the type you want to link.\n",
+ " \n",
+ "\n",
+ " /// this will generate a link to [Foo.Bar] documentation\n",
+ " \n",
+ "\n",
+ "* Add a [Markdown inline code](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code) (using\n",
+ "back-ticks) where the code is the name of the type you want to link.\n",
+ " \n",
+ "\n",
+ " /// This will also generate a link to `Foo.Bar` documentation\n",
+ " \n",
+ "\n",
+ "You can use either the full name (including namespace and module) or the simple name of a type.\n",
+ "If more than one type is found with the same name the link will not be generated.\n",
+ "If a type with the given name is not found in the same assembly the link will not be generated.\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// Contains two types [Bar] and [Foo.Baz]\n",
+ "module Foo =\n",
+ "\n",
+ " /// Bar is just an `int` and belongs to module [Foo]\n",
+ " type Bar = int\n",
+ "\n",
+ " /// Baz contains a `Foo.Bar` as its `id`\n",
+ " type Baz = { id: Bar }\n",
+ "\n",
+ " /// This function operates on `Baz` 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 `Foo3`\n",
+ "module Foo3 =\n",
+ "\n",
+ " /// This is not the same type as `Foo.Bar`\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"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "### Markdown Comments: Excluding APIs from the docs\n",
+ "\n",
+ "If you want to exclude modules or functions from the API docs you can use the `[omit]` tag.\n",
+ "It needs to be set on a separate triple-slashed line, but it could be either the first or the last:\n",
+ "\n",
+ "Example as last line:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// Some actual comment\n",
+ "/// [omit]\n",
+ "module Bar =\n",
+ " let a = 42\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "Example as first line:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "/// [omit]\n",
+ "/// Some actual comment\n",
+ "module Bar2 =\n",
+ " let a = 42\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "## Building library documentation programmatically\n",
+ "\n",
+ "You can build library documentation programatically using the functionality\n",
+ "in the [ApiDocs](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html) type. To do this, 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": [
+ "#r \"FSharp.Formatting.ApiDocs.dll\"\n",
+ "\n",
+ "open FSharp.Formatting.ApiDocs\n",
+ "open System.IO\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "For example the [ApiDocs.GenerateHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#GenerateHtml) method:\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let file = Path.Combine(root, \"bin/YourLibrary.dll\")\n",
+ "\n",
+ "let input = ApiDocInput.FromFile(file)\n",
+ "\n",
+ "ApiDocs.GenerateHtml(\n",
+ " [ input ],\n",
+ " output = Path.Combine(root, \"output\"),\n",
+ " collectionName = \"YourLibrary\",\n",
+ " template = Path.Combine(root, \"templates\", \"template.html\"),\n",
+ " substitutions = []\n",
+ ")\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "### Adding extra dependencies\n",
+ "\n",
+ "When building a library programmatically, you might require a reference to an additional assembly.\n",
+ "You can pass this using the `otherFlags` argument.\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "let projectAssembly = Path.Combine(root, \"bin/X.dll\")\n",
+ "\n",
+ "let projectInput = ApiDocInput.FromFile(projectAssembly)\n",
+ "\n",
+ "ApiDocs.GenerateHtml(\n",
+ " [ projectInput ],\n",
+ " output = Path.Combine(root, \"output\"),\n",
+ " collectionName = \"Project X\",\n",
+ " template = Path.Combine(root, \"templates\", \"template.html\"),\n",
+ " substitutions = [],\n",
+ " otherFlags = [ \"-r:/root/ProjectY/bin/Debug/net6.0/Y.dll\" ]\n",
+ ")\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "or use `libDirs` to include all assemblies from an entire folder.\n",
+ "Tip: A combination of `\u003cCopyLocalLockFileAssemblies\u003etrue\u003c/CopyLocalLockFileAssemblies\u003e` in the fsproj file and setting `libDirs` to the compilation output path leads to only one folder with all dependencies referenced.\n",
+ "This might be easier especially for large projects with many dependencies.\n",
+ "\n"
+ ]
+ }
+,
+ {
+ "cell_type": "code",
+ "metadata": {
+ "dotnet_interactive": {
+ "language": "fsharp"
+ },
+ "polyglot_notebook": {
+ "kernelName": "fsharp"
+ }
+ },
+ "execution_count": null, "outputs": [],
+ "source": [
+ "ApiDocs.GenerateHtml(\n",
+ " [ projectInput ],\n",
+ " output = Path.Combine(root, \"output\"),\n",
+ " collectionName = \"Project X\",\n",
+ " template = Path.Combine(root, \"templates\", \"template.html\"),\n",
+ " substitutions = [],\n",
+ " libDirs = [ \"ProjectX/bin/Debug/netstandard2.0\" ]\n",
+ ")\n"
+ ]
+ }
+,
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "## Rebasing Links\n",
+ "\n",
+ "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\u0027s `\u003cPackageProjectUrl\u003e` property.\n",
+ "\n",
+ "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 \u003cbase\u003e`.\n",
+ "\n",
+ "For example:\n",
+ "\n",
+ " [lang=text]\n",
+ " dotnet fsdocs build --output public/docs --parameters root ../\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/apidocs.md b/apidocs.md
new file mode 100644
index 000000000..dde708de4
--- /dev/null
+++ b/apidocs.md
@@ -0,0 +1,424 @@
+[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath=apidocs.ipynb)
+[](https://fsprojects.github.io/FSharp.Formatting//apidocs.fsx)
+[](https://fsprojects.github.io/FSharp.Formatting//apidocs.ipynb)
+
+# API Documentation Generation
+
+The [command-line tool `fsdocs`](commandline.html) 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.
+
+## Selected projects
+
+`fsdocs` automatically selects the projects and "cracks" the project files for information
+
+* Projects with `GenerateDocumentationFile` and without `IsTestProject` are selected.
+
+* Projects must not use `TargetFrameworks` (only `TargetFramework`, singular).
+
+
+ true
+
+
+## Templates
+
+The HTML is built by instantiating a template. The template used is the first of:
+
+* `docs/reference/_template.html`
+
+
+* `docs/_template.html`
+
+
+* The default template
+
+
+Usually the same template can be used as for [other content](content.html).
+
+## Classic XML Doc Comments
+
+XML Doc Comments may use [the normal F# and C# XML doc standards](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/xmldoc/).
+
+The tags that form the core of the XML doc specification are:
+
+```fsharp
+ *
+ * *
+
+* * *
+*
+
+
+```
+
+In addition, you may also use the [Recommended XML doc extensions for F# documentation tooling](https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md).
+
+* `` links
+
+
+* Arbitrary paragraph-level HTML such as `` for bold in XML doc text
+
+
+* `` giving documentation for the enclosing namespace
+
+
+* `` 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](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`:
+
+```fsharp
+///
+/// A module
+///
+///
+///
+/// A namespace to remember
+///
+/// More on that
+///
+///
+module SomeModule =
+ ///
+ /// Some actual comment
+ /// Another paragraph, see
+ ///
+ ///
+ /// The input
+ ///
+ /// The output
+ ///
+ ///
+ /// Try using
+ ///
+ /// open TheNamespace
+ /// SomeModule.a
+ ///
+ ///
+ ///
+ /// Foo
+ let someFunction x = 42 + x
+
+///
+/// A type, see
+///
+type SomeType() =
+ member x.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:
+
+```fsharp
+type Class2() =
+ member this.Property = "more"
+ member this.Method0() = "more"
+ member this.Method1(c: string) = "more"
+ member this.Method2(c: string, o: obj) = "more"
+
+/// ` to create cross-references.
+
+For example:
+
+```fsharp
+module Forest =
+
+ ///
+ /// Find at most limit foxes in current forest
+ ///
+ /// See also:
+ let findFoxes (limit : int) = []
+
+ ///
+ /// Find at most limit squirrels in current forest
+ ///
+ /// See also:
+ let findSquirrels (limit : int) = []
+```
+
+You can find the correct value for `cref` in the generated `.xml` documentation file (this will be generated alongside the assembly's `.dll``).
+
+You can also omit the `cref`'s arguments, and `fsdocs` will make an attempt to find the first member that matches.
+
+For example:
+
+```fsharp
+ /// See also: ` (for example, you may wish to hide existing documentation while it's in progress).
+The `
+/// BottleKids5 is all you'll ever need in terms of bottles or kids.
+///
+module BottleKids5 =
+ let a = 46
+```
+
+Note that the comments for `BottleKids3` (and `BottleKids4`) will generate a warning. This is because
+the `` tags to remove
+the warning.
+
+The warning will be of the following format:
+
+```fsharp
+Warning: detected "" for "M:YourLib.BottleKids4". Please see https://fsprojects.github.io/FSharp.Formatting/apidocs.html#Classic-XML-Doc-Comments
+
+```
+
+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:
+
+```fsharp
+The use of `[omit]` 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
+
+```
+
+## Go to Source links
+
+'fsdocs' normally automatically adds GitHub links to each functions, values and class members for further reference.
+
+This is normally done automatically based on the following settings:
+
+ https://github.com/...
+ ...
+ git
+
+If your source is not built from the same project where you are building documentation then
+you may need these settings:
+
+ ... -- the URL for the root of the source
+ ... -- the root soure folder at time of build
+
+It is assumed that `sourceRepo` and `sourceFolder` have synchronized contents.
+
+## Markdown Comments
+
+You can use Markdown instead of XML in `///` comments. If you do, you should set `true ` in
+your F# project file.
+
+> Note: Markdown Comments are not supported in all F# IDE tooling.
+>
+
+### Adding cross-type links to modules and types in the same assembly
+
+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](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#links) were the link
+title is the name of the type you want to link.
+
+
+ ```fsharp
+ /// this will generate a link to [Foo.Bar] documentation
+
+ ```
+
+
+* Add a [Markdown inline code](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code) (using
+back-ticks) where the code is the name of the type you want to link.
+
+
+ ```fsharp
+ /// 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.
+
+```fsharp
+/// Contains two types [Bar] and [Foo.Baz]
+module Foo =
+
+ /// Bar is just an `int` and belongs to module [Foo]
+ type Bar = int
+
+ /// Baz contains a `Foo.Bar` as its `id`
+ type Baz = { id: Bar }
+
+ /// This function operates on `Baz` types.
+ let f (b: Baz) = b.id * 42
+
+/// Referencing [Foo3] will not generate a link as there is no type with the name `Foo3`
+module Foo3 =
+
+ /// This is not the same type as `Foo.Bar`
+ type Bar = 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.
+ let f2 b = b * 50
+```
+
+### Markdown Comments: Excluding APIs from the docs
+
+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:
+
+```fsharp
+/// Some actual comment
+/// [omit]
+module Bar =
+ let a = 42
+```
+
+Example as first line:
+
+```fsharp
+/// [omit]
+/// Some actual comment
+module Bar2 =
+ let a = 42
+```
+
+## Building library documentation programmatically
+
+You can build library documentation programatically using the functionality
+in the [ApiDocs](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html) type. To do this, load the assembly and open necessary namespaces:
+
+```fsharp
+#r "FSharp.Formatting.ApiDocs.dll"
+
+open FSharp.Formatting.ApiDocs
+open System.IO
+```
+
+For example the [ApiDocs.GenerateHtml](https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html#GenerateHtml) method:
+
+```fsharp
+let file = Path.Combine(root, "bin/YourLibrary.dll")
+
+let input = ApiDocInput.FromFile(file)
+
+ApiDocs.GenerateHtml(
+ [ input ],
+ output = Path.Combine(root, "output"),
+ collectionName = "YourLibrary",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = []
+)
+```
+
+### Adding extra dependencies
+
+When building a library programmatically, you might require a reference to an additional assembly.
+You can pass this using the `otherFlags` argument.
+
+```fsharp
+let projectAssembly = Path.Combine(root, "bin/X.dll")
+
+let projectInput = ApiDocInput.FromFile(projectAssembly)
+
+ApiDocs.GenerateHtml(
+ [ projectInput ],
+ output = Path.Combine(root, "output"),
+ collectionName = "Project X",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = [],
+ otherFlags = [ "-r:/root/ProjectY/bin/Debug/net6.0/Y.dll" ]
+)
+```
+
+or use `libDirs` to include all assemblies from an entire folder.
+Tip: A combination of `true ` 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.
+
+```fsharp
+ApiDocs.GenerateHtml(
+ [ projectInput ],
+ output = Path.Combine(root, "output"),
+ collectionName = "Project X",
+ template = Path.Combine(root, "templates", "template.html"),
+ substitutions = [],
+ libDirs = [ "ProjectX/bin/Debug/netstandard2.0" ]
+)
+```
+
+## Rebasing Links
+
+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 `` 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
+ true
+
+
+\end{lstlisting}
+\subsection*{Templates}
+
+
+
+The HTML is built by instantiating a template. The template used is the first of:
+\begin{itemize}
+\item
+
+\texttt{docs/reference/\_template.html}
+
+\item
+
+\texttt{docs/\_template.html}
+
+\item
+
+The default template
+
+\end{itemize}
+
+
+
+Usually the same template can be used as for \href{content.html}{other content}.
+\subsection*{Classic XML Doc Comments}
+
+
+
+XML Doc Comments may use \href{https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/xmldoc/}{the normal F\# and C\# XML doc standards}.
+
+
+The tags that form the core of the XML doc specification are:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{<}\id{c}{>} {<}\id{para}{>} {<}\id{see}{>}{*} {<}\id{value}{>}
+{<}\id{code}{>} {<}\id{param}{>}{*} {<}\id{seealso}{>}{*}
+{<}\id{example}{>} {<}\id{paramref}{>} {<}\id{summary}{>}
+{<}\kwd{exception}{>}{*} {<}\id{permission}{>}{*} {<}\id{typeparam}{>}{*}
+{<}\id{include}{>}{*} {<}\id{remarks}{>} {<}\id{typeparamref}{>}
+{<}\id{list}{>} {<}\id{inheritdoc}{>} {<}\id{returns}{>}
+
+
+\end{lstlisting}
+
+
+
+In addition, you may also use the \href{https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md}{Recommended XML doc extensions for F\# documentation tooling}.
+\begin{itemize}
+\item
+
+\texttt{} links
+
+\item
+
+Arbitrary paragraph-level HTML such as \texttt{} for bold in XML doc text
+
+\item
+
+\texttt{} giving documentation for the enclosing namespace
+
+\item
+
+\texttt{} to give a category for an entity or member. An optional \texttt{index} attribute can be specified
+to help sort the list of categories.
+
+\item
+
+\texttt{{\textbackslash}(...{\textbackslash})} for inline math and \texttt{\$\$...\$\$} and \texttt{{\textbackslash}[...{\textbackslash}]}for math environments, see \href{http://docs.mathjax.org.
+Some}{http://docs.mathjax.org.
+Some} escaping of characters (e.g. \texttt{<}, \texttt{>}) may be needed to form valid XML
+
+\end{itemize}
+
+
+
+An example of an XML documentation comment, assuming the code is in namespace \texttt{TheNamespace}:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// }
+\com{/// A module}
+\com{/// }
+\com{///}
+\com{/// }
+\com{/// A namespace to remember }
+\com{///}
+\com{/// More on that }
+\com{/// }
+\com{///}
+\kwd{module} \ltyp{SomeModule} \ops{=}
+ \com{/// }
+ \com{/// Some actual comment}
+ \com{/// Another paragraph, see }
+ \com{/// }
+ \com{///}
+ \com{/// The input}
+ \com{///}
+ \com{/// The output }
+ \com{///}
+ \com{/// }
+ \com{/// Try using}
+ \com{/// }
+ \com{/// open TheNamespace}
+ \com{/// SomeModule.a}
+ \com{/// }
+ \com{/// }
+ \com{///}
+ \com{/// Foo }
+ \kwd{let} \lfun{someFunction} \lfun{x} \ops{=} \num{42} \ops{+} \lfun{x}
+
+\com{/// }
+\com{/// A type, see }
+\com{///}
+\kwd{type} \ltyp{SomeType}{(}{)} \ops{=}
+ \kwd{member} \lfun{x}{.}{P} \ops{=} \num{1}
+
+\end{lstlisting}
+
+
+
+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:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{type} \ltyp{Class2}{(}{)} \ops{=}
+ \kwd{member} \lfun{this}{.}{Property} \ops{=} \str{"more"}
+ \kwd{member} \lfun{this}{.}\lfun{Method0}{(}{)} \ops{=} \str{"more"}
+ \kwd{member} \lfun{this}{.}\lfun{Method1}{(}\lfun{c}{:} \ltyp{string}{)} \ops{=} \str{"more"}
+ \kwd{member} \lfun{this}{.}\lfun{Method2}{(}\lfun{c}{:} \ltyp{string}{,} \lfun{o}{:} \ltyp{obj}{)} \ops{=} \str{"more"}
+
+\com{/// }
+
+
+
+Use \texttt{} to create cross-references.
+
+
+For example:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{module} \ltyp{Forest} \ops{=}
+
+ \com{/// }
+ \com{/// Find at most limit foxes in current forest}
+ \com{///}
+ \com{/// See also: }
+ \kwd{let} \lfun{findFoxes} {(}\lfun{limit} {:} \ltyp{int}{)} \ops{=} {[}{]}
+
+ \com{/// }
+ \com{/// Find at most limit squirrels in current forest}
+ \com{///}
+ \com{/// See also: }
+ \kwd{let} \lfun{findSquirrels} {(}\lfun{limit} {:} \ltyp{int}{)} \ops{=} {[}{]}
+
+\end{lstlisting}
+
+
+
+You can find the correct value for \texttt{cref} in the generated \texttt{.xml} documentation file (this will be generated alongside the assembly's \texttt{.dll}`).
+
+
+You can also omit the \texttt{cref}'s arguments, and \texttt{fsdocs} will make an attempt to find the first member that matches.
+
+
+For example:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+ \com{/// See also: } (for example, you may wish to hide existing documentation while it's in progress).
+The \texttt{}
+\com{/// BottleKids5 is all you'll ever need in terms of bottles or kids.}
+\com{/// }
+\kwd{module} \ltyp{BottleKids5} \ops{=}
+ \kwd{let} \id{a} \ops{=} \num{46}
+
+\end{lstlisting}
+
+
+
+Note that the comments for \texttt{BottleKids3} (and \texttt{BottleKids4}) will generate a warning. This is because
+the \texttt{} tags to remove
+the warning.
+
+
+The warning will be of the following format:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\id{Warning}{:} \id{detected} \str{""} \kwd{for} \str{"M:YourLib.BottleKids4"}{.} \id{Please} \id{see} \id{https}{:}\com{//fsprojects.github.io/FSharp.Formatting/apidocs.html\#Classic-XML-Doc-Comments}
+
+
+\end{lstlisting}
+
+
+
+You will find that \texttt{[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:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\id{The} \kwd{use} \kwd{of} \id{`}{[}\id{omit}{]}\id{`} \kwd{and} \id{other} \id{commands} \kwd{in} \id{XML} \id{comments} \id{is} \id{deprecated}{,} \id{please} \kwd{use} \id{XML} \id{extensions}{,} \id{see} \id{https}{:}\com{//github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md}
+
+
+\end{lstlisting}
+
+\subsection*{Go to Source links}
+
+
+
+'fsdocs' normally automatically adds GitHub links to each functions, values and class members for further reference.
+
+
+This is normally done automatically based on the following settings:
+\begin{lstlisting}
+ https://github.com/...
+ ...
+ git
+
+\end{lstlisting}
+
+
+If your source is not built from the same project where you are building documentation then
+you may need these settings:
+\begin{lstlisting}
+ ... -- the URL for the root of the source
+ ... -- the root soure folder at time of build
+
+\end{lstlisting}
+
+
+It is assumed that \texttt{sourceRepo} and \texttt{sourceFolder} have synchronized contents.
+\subsection*{Markdown Comments}
+
+
+
+You can use Markdown instead of XML in \texttt{///} comments. If you do, you should set \texttt{true } in
+your F\# project file.
+\begin{quote}
+
+
+Note: Markdown Comments are not supported in all F\# IDE tooling.
+\end{quote}
+
+\subsubsection*{Adding cross-type links to modules and types in the same assembly}
+
+
+
+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:
+\begin{itemize}
+\item
+
+Add a \href{https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet\#links}{markdown inline link} were the link
+title is the name of the type you want to link.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// this will generate a link to [Foo.Bar] documentation}
+
+
+\end{lstlisting}
+
+
+\item
+
+Add a \href{https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet\#code}{Markdown inline code} (using
+back-ticks) where the code is the name of the type you want to link.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// This will also generate a link to `Foo.Bar` documentation}
+
+
+\end{lstlisting}
+
+
+\end{itemize}
+
+
+
+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.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// Contains two types [Bar] and [Foo.Baz]}
+\kwd{module} \ltyp{Foo} \ops{=}
+
+ \com{/// Bar is just an `int` and belongs to module [Foo]}
+ \kwd{type} \ltyp{Bar} \ops{=} \ltyp{int}
+
+ \com{/// Baz contains a `Foo.Bar` as its `id`}
+ \kwd{type} \ltyp{Baz} \ops{=} {\{} {id}{:} \ltyp{Bar} {\}}
+
+ \com{/// This function operates on `Baz` types.}
+ \kwd{let} \lfun{f} {(}\lfun{b}{:} \ltyp{Baz}{)} \ops{=} \lfun{b}{.}\id{id} \ops{*} \num{42}
+
+\com{/// Referencing [Foo3] will not generate a link as there is no type with the name `Foo3`}
+\kwd{module} \ltyp{Foo3} \ops{=}
+
+ \com{/// This is not the same type as `Foo.Bar`}
+ \kwd{type} \ltyp{Bar} \ops{=} \ltyp{double}
+
+ \com{/// Using the simple name for [Bar] will fail to create a link because the name is duplicated in}
+ \com{/// [Foo.Bar] and in [Foo3.Bar]. In this case, using the full name works.}
+ \kwd{let} \lfun{f2} \lfun{b} \ops{=} \lfun{b} \ops{*} \num{50}
+
+\end{lstlisting}
+
+\subsubsection*{Markdown Comments: Excluding APIs from the docs}
+
+
+
+If you want to exclude modules or functions from the API docs you can use the \texttt{[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:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// Some actual comment}
+\com{/// [omit]}
+\kwd{module} \ltyp{Bar} \ops{=}
+ \kwd{let} \id{a} \ops{=} \num{42}
+
+\end{lstlisting}
+
+
+
+Example as first line:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\com{/// [omit]}
+\com{/// Some actual comment}
+\kwd{module} \ltyp{Bar2} \ops{=}
+ \kwd{let} \id{a} \ops{=} \num{42}
+
+\end{lstlisting}
+
+\subsection*{Building library documentation programmatically}
+
+
+
+You can build library documentation programatically using the functionality
+in the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html}{ApiDocs} type. To do this, load the assembly and open necessary namespaces:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\prep{\#r} \str{"FSharp.Formatting.ApiDocs.dll"}
+
+\kwd{open} \id{FSharp}{.}\id{Formatting}{.}\id{ApiDocs}
+\kwd{open} \id{System}{.}\id{IO}
+
+\end{lstlisting}
+
+
+
+For example the \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocs.html\#GenerateHtml}{ApiDocs.GenerateHtml} method:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{file} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"bin/YourLibrary.dll"}{)}
+
+\kwd{let} \id{input} \ops{=} \ltyp{ApiDocInput}{.}\id{FromFile}{(}\id{file}{)}
+
+\ltyp{ApiDocs}{.}\id{GenerateHtml}{(}
+ {[} \id{input} {]}{,}
+ \lfun{output} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"output"}{)}{,}
+ \lfun{collectionName} \ops{=} \str{"YourLibrary"}{,}
+ \lfun{template} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"templates"}{,} \str{"template.html"}{)}{,}
+ \lfun{substitutions} \ops{=} {[}{]}
+{)}
+
+\end{lstlisting}
+
+\subsubsection*{Adding extra dependencies}
+
+
+
+When building a library programmatically, you might require a reference to an additional assembly.
+You can pass this using the \texttt{otherFlags} argument.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\kwd{let} \id{projectAssembly} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"bin/X.dll"}{)}
+
+\kwd{let} \id{projectInput} \ops{=} \ltyp{ApiDocInput}{.}\id{FromFile}{(}\id{projectAssembly}{)}
+
+\ltyp{ApiDocs}{.}\id{GenerateHtml}{(}
+ {[} \id{projectInput} {]}{,}
+ \lfun{output} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"output"}{)}{,}
+ \lfun{collectionName} \ops{=} \str{"Project X"}{,}
+ \lfun{template} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"templates"}{,} \str{"template.html"}{)}{,}
+ \lfun{substitutions} \ops{=} {[}{]}{,}
+ \lfun{otherFlags} \ops{=} {[} \str{"-r:/root/ProjectY/bin/Debug/net6.0/Y.dll"} {]}
+{)}
+
+\end{lstlisting}
+
+
+
+or use \texttt{libDirs} to include all assemblies from an entire folder.
+Tip: A combination of \texttt{true } in the fsproj file and setting \texttt{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.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\ltyp{ApiDocs}{.}\id{GenerateHtml}{(}
+ {[} \id{projectInput} {]}{,}
+ \lfun{output} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"output"}{)}{,}
+ \lfun{collectionName} \ops{=} \str{"Project X"}{,}
+ \lfun{template} \ops{=} \ltyp{Path}{.}\id{Combine}{(}\id{root}{,} \str{"templates"}{,} \str{"template.html"}{)}{,}
+ \lfun{substitutions} \ops{=} {[}{]}{,}
+ \lfun{libDirs} \ops{=} {[} \str{"ProjectX/bin/Debug/netstandard2.0"} {]}
+{)}
+
+\end{lstlisting}
+
+\subsection*{Rebasing Links}
+
+
+
+The \texttt{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 \texttt{} property.
+
+
+In some instances, you may wish to override the value for \texttt{root} (perhaps for local testing). To do this, you can use the command-line argument \texttt{--parameters root
+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.html b/codeformat.html
new file mode 100644
index 000000000..30d47cb35
--- /dev/null
+++ b/codeformat.html
@@ -0,0 +1,362 @@
+
+
+
+
+
+ Code formatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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:
+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 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:
+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 as documented in the
+about page.
+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:
+// 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:
+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 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:
+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.
+
+ Multiple items
namespace FSharp
--------------------
namespace Microsoft.FSharp
+namespace FSharp.Formatting
+namespace FSharp.Formatting.CodeFormat
+namespace System
+namespace System.Reflection
+val source: string
+val snippets: Snippet array
+val diagnostics: SourceError array
+module CodeFormatter
+
+from FSharp.Formatting.CodeFormat
<summary>
+ Uses agent to handle formatting requests
+</summary>
+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: string * Line list -> Snippet
--------------------
type Snippet = | Snippet of string * 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 TokenKind * string * ToolTipSpans option
+ | Error of ErrorKind * string * TokenSpans
+ | Omitted of string * 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: TokenKind * string * 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: string * string -> TokenSpan
+union case TokenSpan.Output: string -> TokenSpan
+union case TokenSpan.Error: ErrorKind * string * 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>
+static member CodeFormat.FormatHtml: snippets: Snippet array * prefix: string * ?openTag: string * ?closeTag: string * ?lineNumbers: bool * ?openLinesTag: string * ?closeLinesTag: string * ?addErrors: bool * ?tokenKindToCss: (TokenKind -> string) -> FormattedContent
+val snip: FormattedSnippet
+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..25ce7bb76
--- /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,19.1.1\"\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..c7bedeaf0
--- /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 Lunr search index is automatically generated in `index.json`.
+
+A search box is included in the default template. To add a search box
+to your own `_template.html`, include `fsdocs-search.js`, which is added to the `content`
+by default.
+
+ [lang=text]
+ ...
+
+
+
+
+
+
+
+
+
+ ...
+
+
+*)
+
diff --git a/commandline.html b/commandline.html
new file mode 100644
index 000000000..1b474b0c5
--- /dev/null
+++ b/commandline.html
@@ -0,0 +1,352 @@
+
+
+
+
+
+ Command line
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Command line
+To use F# Formatting tools via the command line, you can use the fsdocs dotnet tool.
+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. 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)
+-
+
The project does not contain
+<GenerateDocumentationFile>true</GenerateDocumentationFile>
+
+
+
+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").
+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.
+
+--port
Port to serve content for http://localhost serving.
+
+
+
+Searchable docs
+When using the command-line tool a Lunr search index is automatically generated in index.json.
+A search box is included in the default template. To add a search box
+to your own _template.html, include fsdocs-search.js, which is added to the content
+by default.
+...
+<div id="header">
+ <div class="searchbox">
+ <label for="search-by">
+ <i class="fas fa-search"></i>
+ </label>
+ <input data-search-input="" id="search-by" type="search" placeholder="Search..." />
+ <span data-search-clear="">
+ <i class="fas fa-times"></i>
+ </span>
+ </div>
+</div>
+...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/commandline.ipynb b/commandline.ipynb
new file mode 100644
index 000000000..183226550
--- /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 Lunr search index is automatically generated in `index.json`.\n",
+ "\n",
+ "A search box is included in the default template. To add a search box\n",
+ "to your own `_template.html`, include `fsdocs-search.js`, which is added to the `content`\n",
+ "by default.\n",
+ "\n",
+ " [lang=text]\n",
+ " ...\n",
+ " \u003cdiv id=\"header\"\u003e\n",
+ " \u003cdiv class=\"searchbox\"\u003e\n",
+ " \u003clabel for=\"search-by\"\u003e\n",
+ " \u003ci class=\"fas fa-search\"\u003e\u003c/i\u003e\n",
+ " \u003c/label\u003e\n",
+ " \u003cinput data-search-input=\"\" id=\"search-by\" type=\"search\" placeholder=\"Search...\" /\u003e\n",
+ " \u003cspan data-search-clear=\"\"\u003e\n",
+ " \u003ci class=\"fas fa-times\"\u003e\u003c/i\u003e\n",
+ " \u003c/span\u003e\n",
+ " \u003c/div\u003e\n",
+ " \u003c/div\u003e\n",
+ " ...\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..71a81181d
--- /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 Lunr search index is automatically generated in `index.json`.
+
+A search box is included in the default template. To add a search box
+to your own `_template.html`, include `fsdocs-search.js`, which is added to the `content`
+by default.
+
+ [lang=text]
+ ...
+
+
+
+
+
+
+
+
+
+ ...
+
+
+
diff --git a/commandline.tex b/commandline.tex
new file mode 100644
index 000000000..202dd11fc
--- /dev/null
+++ b/commandline.tex
@@ -0,0 +1,180 @@
+\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 Lunr search index is automatically generated in \texttt{index.json}.
+
+
+A search box is included in the default template. To add a search box
+to your own \texttt{\_template.html}, include \texttt{fsdocs-search.js}, which is added to the \texttt{content}
+by default.
+\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..8f24d97fb
--- /dev/null
+++ b/content.fsx
@@ -0,0 +1,222 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,19.1.1"
+(**
+[](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-styles.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 and ordering.
+
+For markdown, the format is:
+
+```
+---
+title: Some Title
+category: Some Category
+categoryindex: 2
+index: 3
+---
+```
+For F# scripts the frontmatter is in this form:
+
+ (**
+ ---
+ title: A Literate Script
+ category: Examples
+ categoryindex: 2
+ index: 1
+ ---
+ *)
+
+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.
+
+## Link Translation for Inputs
+
+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:
+
+ [Some Text](some-file.md)
+
+becomes
+
+ [Some Text](some-file.html)
+
+if `some-file.md` is one of the inputs.
+
+## Multi-language Content
+
+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 and Substitutions
+
+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](styling.html) for information about template parameters and styling beyond the default template.
+
+Substitution name | Generated content
+:--- | :---
+`root` | `` 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
+
+
+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..970e1b579
--- /dev/null
+++ b/content.html
@@ -0,0 +1,394 @@
+
+
+
+
+
+ Creating Content
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Creating Content
+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:
+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 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-styles.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 and ordering.
+For markdown, the format is:
+---
+title: Some Title
+category: Some Category
+categoryindex: 2
+index: 3
+---
+
+For F# scripts the frontmatter is in this form:
+(**
+---
+title: A Literate Script
+category: Examples
+categoryindex: 2
+index: 1
+---
+*)
+
+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.
+Link Translation for Inputs
+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:
+[Some Text](some-file.md)
+
+becomes
+[Some Text](some-file.html)
+
+if some-file.md is one of the inputs.
+Multi-language Content
+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 and Substitutions
+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
+
+
+
+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.
+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.
+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.
+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.
+
+ 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..7ebf79588
--- /dev/null
+++ b/content.ipynb
@@ -0,0 +1,280 @@
+
+{
+ "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,19.1.1\"\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-styles.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 and ordering.\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",
+ "---\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",
+ " ---\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",
+ "\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",
+ "\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..9b6b041f0
--- /dev/null
+++ b/content.md
@@ -0,0 +1,235 @@
+[](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-styles.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 and ordering.
+
+For markdown, the format is:
+
+```fsharp
+---
+title: Some Title
+category: Some Category
+categoryindex: 2
+index: 3
+---
+
+```
+
+For F# scripts the frontmatter is in this form:
+
+```fsharp
+(**
+---
+title: A Literate Script
+category: Examples
+categoryindex: 2
+index: 1
+---
+*)
+
+```
+
+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.
+
+## Link Translation for Inputs
+
+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:
+
+```fsharp
+[Some Text](some-file.md)
+
+```
+
+becomes
+
+```fsharp
+[Some Text](some-file.html)
+
+```
+
+if `some-file.md` is one of the inputs.
+
+## Multi-language Content
+
+Versions of content in other languages should go in two-letter coded sub-directories, e.g.
+
+```fsharp
+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 and Substitutions
+
+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](styling.html) for information about template parameters and styling beyond the default template.
+
+Substitution name | Generated content
+:--- | :---
+`root` | `` 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
+
+
+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..f35c0dd72
--- /dev/null
+++ b/content.tex
@@ -0,0 +1,365 @@
+\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-styles.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 and ordering.
+
+
+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}
+\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{---}
+\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.
+\subsection*{Link Translation for Inputs}
+
+
+
+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:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{[}\id{Some} \id{Text}{]}{(}\id{some}\ops{-}\id{file}{.}\id{md}{)}
+
+
+\end{lstlisting}
+
+
+
+becomes
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{[}\id{Some} \id{Text}{]}{(}\id{some}\ops{-}\id{file}{.}\id{html}{)}
+
+
+\end{lstlisting}
+
+
+
+if \texttt{some-file.md} is one of the inputs.
+\subsection*{Multi-language Content}
+
+
+
+Versions of content in other languages should go in two-letter coded sub-directories, e.g.
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+\id{docs}\ops{/}\id{ja}\ops{/...}
+\id{docs}\ops{/}\id{de}\ops{/...}
+
+
+\end{lstlisting}
+
+
+
+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).
+\subsection*{Templates and Substitutions}
+
+
+
+Templates are used for HTML (\texttt{\_template.html}), LaTeX (\texttt{\_template.tex}), Notebooks (\texttt{\_template.ipynb)}
+and F\# script outputs (\texttt{\_template.fsx}).
+
+
+The following substitutions determine the primary (non-styling) content of your site.
+For example \texttt{\{\{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 \texttt{`...`}, Markdown LaTeX and
+generated outputs.
+
+
+See \href{styling.html}{Styling} for information about template parameters and styling beyond the default template.
+\begin{tabular}{|l|l|}\hline
+\textbf{Substitution name} & \textbf{Generated content}\\ \hline\hline
+\texttt{root} & \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{ } list of documents with titles and links\\ \hline
+\texttt{fsdocs-page-title} & First h1 heading in literate file. Generated for API docs\\ \hline
+\texttt{fsdocs-source} & Original literate script or markdown source\\ \hline
+\texttt{fsdocs-source-filename} & Name of original input source, relative to the \texttt{docs} root\\ \hline
+\texttt{fsdocs-source-basename} & Name of original input source, excluding its extensions, relative to the \texttt{docs} root\\ \hline
+\texttt{fsdocs-tooltips} & Generated hidden div elements for tooltips\\ \hline
+\texttt{fsdocs-watch-script} & The websocket script used in watch mode to trigger hot reload\\ \hline
+\texttt{fsdocs-previous-page-link} & A relative link to the previous page based on the frontmatter index data\\ \hline
+\texttt{fsdocs-next-page-link} & A relative link to the next page based on the frontmatter index data\\ \hline
+\end{tabular}
+
+
+
+The following substitutions are extracted from your project files and may or may not be used by the default
+template:
+\begin{tabular}{|l|l|}\hline
+\textbf{Substitution name} & \textbf{Value}\\ \hline\hline
+\texttt{fsdocs-copyright} & \texttt{}\\ \hline
+\texttt{fsdocs-package-project-url} & \texttt{}\\ \hline
+\texttt{fsdocs-package-license-expression} & \texttt{}\\ \hline
+\texttt{fsdocs-package-tags} & \texttt{}\\ \hline
+\texttt{fsdocs-package-version} & \texttt{}\\ \hline
+\end{tabular}
+
+
+
+For the \texttt{fsdocs} tool, additional substitutions can be specified using \texttt{--parameters}.
+\subsection*{Cross References to API Docs}
+
+
+
+Markdown content can contain cross-references to API Docs. Use inline
+markdown code snippets of the special form \texttt{`cref:T:MyNamespace.MyType`} where \texttt{T:MyNamespace.MyType}
+is a method, property or type xml doc sig reference, see \href{apidocs.html}{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,
+\begin{itemize}
+\item
+
+the text \texttt{`cref:T:FSharp.Formatting.Markdown.MarkdownParagraph`} resolves to the link \href{https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html}{MarkdownParagraph}
+
+\item
+
+the text \texttt{`cref:T:System.Console`} resolves to the link \href{https://learn.microsoft.com/dotnet/api/system.console}{Console}
+
+\item
+
+the text \texttt{`cref:M:System.Console.WriteLine`} resolves to the link \href{https://learn.microsoft.com/dotnet/api/system.console.writeline}{Console.WriteLine}
+
+\item
+
+the text \texttt{`cref:M:System.Console.WriteLine(System.String)`} resolves to the link \href{https://learn.microsoft.com/dotnet/api/system.console.writeline}{Console.WriteLine}
+
+\item
+
+the text \texttt{``cref:T:FSharp.Control.FSharpAsync`1``} resolves to the link \href{https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync-1}{Async}
+
+\item
+
+the text \texttt{`cref:T:FSharp.Control.FSharpAsync`} resolves to the link \href{https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-fsharpasync}{Async}
+
+\item
+
+the text \texttt{``cref:T:FSharp.Core.array`1``} resolves to the link \href{https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-array-1}{array}
+
+\item
+
+the text \texttt{`cref:T:FSharp.Core.OptionModule`} resolves to the link \href{https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-optionmodule}{Option}
+
+\item
+
+the text \texttt{```cref:M:FSharp.Collections.ListModule.Append``1```} resolves to the link \href{https://fsharp.github.io/fsharp-core-docs/reference/fsharp-collections-listmodule\#Append}{ListModule.Append}
+
+\end{itemize}
+
+\begin{quote}
+
+
+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. \href{https://github.com/fsprojects/FSharp.Formatting/issues/new}{Please report it}.
+\end{quote}
+
+
+
+Determining xmldoc sig references is not simple. The API doc generated pages come with
+buttons to copy out the XmlDoc signature.
+\subsection*{Generating HTML Output}
+
+
+
+HTML is generated by default. You can also add a \texttt{\_template.html}. This should contain \texttt{\{\{fsdocs-content\}\}}, \texttt{\{\{fsdocs-tooltips\}\}}
+and other placeholders. Substitutions are
+applied to this template.
+If a file \texttt{\_template.html} exists then is used as the template for HTML generation for that directory and all sub-content.
+\subsection*{Generating LaTeX output}
+
+
+
+To generate .tex output for each script and markdown file, add a \texttt{\_template.tex}. Substitutions are
+applied to this template. The file is either empty of contains \texttt{\{\{fsdocs-content\}\}} as the key where the body
+of the document is placed.
+\subsection*{Generating iPython Notebook output}
+
+
+
+To generate .ipynb output for each script and markdown file, add a \texttt{\_template.ipynb}, usually empty. Substitutions are
+applied to this template.
+
+
+To add a \texttt{mybinder} badge to your generated notebook, ensure you have a \texttt{Dockerfile} and \texttt{NuGet.config}
+in your \texttt{docs} directory and use text like this:
+\begin{lstlisting}[numbers=left]
+
+[escapeinside=\\\{\}]
+{[}\ops{!}{[}\id{Binder}{]}{(}\id{https}{:}\com{//mybinder.org/badge\_logo.svg)](https://mybinder.org/v2/gh/fsprojects/FSharp.Formatting/gh-pages?filepath=literate.ipynb)}
+
+
+\end{lstlisting}
+
+\subsection*{Generating Script outputs}
+
+
+
+To generate .fsx output for each script and markdown file, add a \texttt{\_template.fsx}, usually empty. Substitutions are
+applied to this template. It is either empty of contains \texttt{\{\{fsdocs-content\}\}} as the key where the body
+of the script is placed.
+
+
+\end{document}
\ No newline at end of file
diff --git a/content/fsdocs-custom.css b/content/fsdocs-custom.css
new file mode 100644
index 000000000..c32465db8
--- /dev/null
+++ b/content/fsdocs-custom.css
@@ -0,0 +1,5 @@
+
+/*--------------------------------------------------------------------------
+ Customize your CSS here
+/*--------------------------------------------------------------------------*/
+
diff --git a/content/fsdocs-default.css b/content/fsdocs-default.css
new file mode 100644
index 000000000..bf73bfa5a
--- /dev/null
+++ b/content/fsdocs-default.css
@@ -0,0 +1,613 @@
+@import url('https://fonts.googleapis.com/css2?family=Hind+Vadodara&family=Roboto+Mono:wght@400;500;600&display=swap');
+/*--------------------------------------------------------------------------
+ Formatting for page & standard document content
+/*--------------------------------------------------------------------------*/
+
+body {
+ font-family: 'Hind Vadodara', sans-serif;
+ /* padding-top: 0px;
+ padding-bottom: 40px;
+*/
+}
+
+blockquote {
+ margin: 0 1em 0 0.25em;
+ margin-top: 0px;
+ margin-right: 1em;
+ margin-bottom: 0px;
+ margin-left: 0.25em;
+ padding: 0 .75em 0 1em;
+ border-left: 1px solid #777;
+ border-right: 0px solid #777;
+}
+
+/* Format the heading - nicer spacing etc. */
+.masthead {
+ overflow: hidden;
+}
+
+ .masthead .muted a {
+ text-decoration: none;
+ color: #999999;
+ }
+
+ .masthead ul, .masthead li {
+ margin-bottom: 0px;
+ }
+
+ .masthead .nav li {
+ margin-top: 15px;
+ font-size: 110%;
+ }
+
+ .masthead h3 {
+ margin-top: 15px;
+ margin-bottom: 5px;
+ font-size: 170%;
+ }
+
+/*--------------------------------------------------------------------------
+ Formatting fsdocs-content
+/*--------------------------------------------------------------------------*/
+
+/* Change font sizes for headings etc. */
+#fsdocs-content h1 {
+ margin: 30px 0px 15px 0px;
+ /* font-weight: 400; */
+ font-size: 2rem;
+ letter-spacing: 1.78px;
+ line-height: 2.5rem;
+ font-weight: 400;
+}
+
+#fsdocs-content h2 {
+ font-size: 1.6rem;
+ margin: 20px 0px 10px 0px;
+ font-weight: 400;
+}
+
+#fsdocs-content h3 {
+ font-size: 1.2rem;
+ margin: 15px 0px 10px 0px;
+ font-weight: 400;
+}
+
+#fsdocs-content hr {
+ margin: 0px 0px 20px 0px;
+}
+
+#fsdocs-content li {
+ font-size: 1.0rem;
+ line-height: 1.375rem;
+ letter-spacing: 0.01px;
+ font-weight: 500;
+ margin: 0px 0px 15px 0px;
+}
+
+#fsdocs-content p {
+ font-size: 1.0rem;
+ line-height: 1.375rem;
+ letter-spacing: 0.01px;
+ font-weight: 500;
+ color: #262626;
+}
+
+#fsdocs-content a {
+ color: #4974D1;
+}
+/* remove the default bootstrap bold on dt elements */
+#fsdocs-content dt {
+ font-weight: normal;
+}
+
+
+
+/*--------------------------------------------------------------------------
+ Formatting tables in fsdocs-content, using learn.microsoft.com tables
+/*--------------------------------------------------------------------------*/
+
+#fsdocs-content .table {
+ table-layout: auto;
+ width: 100%;
+ font-size: 0.875rem;
+}
+
+ #fsdocs-content .table caption {
+ font-size: 0.8rem;
+ font-weight: 600;
+ letter-spacing: 2px;
+ text-transform: uppercase;
+ padding: 1.125rem;
+ border-width: 0 0 1px;
+ border-style: solid;
+ border-color: #e3e3e3;
+ text-align: right;
+ }
+
+ #fsdocs-content .table td,
+ #fsdocs-content .table th {
+ display: table-cell;
+ word-wrap: break-word;
+ padding: 0.75rem 1rem 0.75rem 0rem;
+ line-height: 1.5;
+ vertical-align: top;
+ border-top: 1px solid #e3e3e3;
+ border-right: 0;
+ border-left: 0;
+ border-bottom: 0;
+ border-style: solid;
+ }
+
+ /* suppress the top line on inner lists such as tables of exceptions */
+ #fsdocs-content .table .fsdocs-exception-list td,
+ #fsdocs-content .table .fsdocs-exception-list th {
+ border-top: 0
+ }
+
+ #fsdocs-content .table td p:first-child,
+ #fsdocs-content .table th p:first-child {
+ margin-top: 0;
+ }
+
+ #fsdocs-content .table td.nowrap,
+ #fsdocs-content .table th.nowrap {
+ white-space: nowrap;
+ }
+
+ #fsdocs-content .table td.is-narrow,
+ #fsdocs-content .table th.is-narrow {
+ width: 15%;
+ }
+
+ #fsdocs-content .table th:not([scope='row']) {
+ border-top: 0;
+ border-bottom: 1px;
+ }
+
+ #fsdocs-content .table > caption + thead > tr:first-child > td,
+ #fsdocs-content .table > colgroup + thead > tr:first-child > td,
+ #fsdocs-content .table > thead:first-child > tr:first-child > td {
+ border-top: 0;
+ }
+
+ #fsdocs-content .table table-striped > tbody > tr:nth-of-type(odd) {
+ background-color: var(--box-shadow-light);
+ }
+
+ #fsdocs-content .table.min {
+ width: unset;
+ }
+
+ #fsdocs-content .table.is-left-aligned td:first-child,
+ #fsdocs-content .table.is-left-aligned th:first-child {
+ padding-left: 0;
+ }
+
+ #fsdocs-content .table.is-left-aligned td:first-child a,
+ #fsdocs-content .table.is-left-aligned th:first-child a {
+ outline-offset: -0.125rem;
+ }
+
+@media screen and (max-width: 767px), screen and (min-resolution: 120dpi) and (max-width: 767.9px) {
+ #fsdocs-content .table.is-stacked-mobile td:nth-child(1) {
+ display: block;
+ width: 100%;
+ padding: 1rem 0;
+ }
+
+ #fsdocs-content .table.is-stacked-mobile td:not(:nth-child(1)) {
+ display: block;
+ border-width: 0;
+ padding: 0 0 1rem;
+ }
+}
+
+#fsdocs-content .table.has-inner-borders th,
+#fsdocs-content .table.has-inner-borders td {
+ border-right: 1px solid #e3e3e3;
+}
+
+ #fsdocs-content .table.has-inner-borders th:last-child,
+ #fsdocs-content .table.has-inner-borders td:last-child {
+ border-right: none;
+ }
+
+.fsdocs-entity-list .fsdocs-entity-name {
+ width: 25%;
+ font-weight: bold;
+}
+
+.fsdocs-member-list .fsdocs-member-usage {
+ width: 35%;
+}
+
+/*--------------------------------------------------------------------------
+ Formatting xmldoc sections in fsdocs-content
+/*--------------------------------------------------------------------------*/
+
+.fsdocs-summary {
+ display: inline;
+}
+
+.fsdocs-xmldoc, .fsdocs-entity-xmldoc, .fsdocs-member-xmldoc {
+ font-size: 1.0rem;
+ line-height: 1.375rem;
+ letter-spacing: 0.01px;
+ font-weight: 500;
+ color: #262626;
+}
+
+.fsdocs-xmldoc h1 {
+ font-size: 1.2rem;
+ margin: 10px 0px 0px 0px;
+}
+
+.fsdocs-xmldoc h2 {
+ font-size: 1.2rem;
+ margin: 10px 0px 0px 0px;
+}
+
+.fsdocs-xmldoc h3 {
+ font-size: 1.1rem;
+ margin: 10px 0px 0px 0px;
+}
+
+.fsdocs-member-xmldoc details[open] summary + * {
+ margin-top: 1rem;
+}
+
+/* #fsdocs-nav .searchbox {
+ margin-top: 30px;
+ margin-bottom: 30px;
+} */
+
+#fsdocs-nav img.logo{
+ width:90%;
+ /* height:140px; */
+ /* margin:10px 0px 0px 20px; */
+ margin-top:40px;
+ border-style:none;
+}
+
+#fsdocs-nav input{
+ /* margin-left: 20px; */
+ margin-right: 20px;
+ margin-top: 20px;
+ margin-bottom: 20px;
+ width: 93%;
+ -webkit-border-radius: 0;
+ border-radius: 0;
+}
+
+#fsdocs-nav {
+ /* margin-left: -5px; */
+ /* width: 90%; */
+ font-size:0.95rem;
+}
+
+#fsdocs-nav li.nav-header{
+ /* margin-left: -5px; */
+ /* width: 90%; */
+ padding-left: 0;
+ color: #262626;
+ text-transform: none;
+ font-size:16px;
+ margin-top: 9px;
+ font-weight: bold;
+}
+
+#fsdocs-nav a{
+ padding-left: 0;
+ color: #6c6c6d;
+ /* margin-left: 5px; */
+ /* width: 90%; */
+}
+
+/*--------------------------------------------------------------------------
+ Formatting pre and code sections in fsdocs-content (code highlighting is
+ further below)
+/*--------------------------------------------------------------------------*/
+
+#fsdocs-content code {
+ /* font-size: 0.83rem; */
+ font: 0.85rem 'Roboto Mono', monospace;
+ background-color: #f7f7f900;
+ border: 0px;
+ padding: 0px;
+ /* word-wrap: break-word; */
+ /* white-space: pre; */
+}
+
+/* omitted */
+#fsdocs-content span.omitted {
+ background: #3c4e52;
+ border-radius: 5px;
+ color: #808080;
+ padding: 0px 0px 1px 0px;
+}
+
+#fsdocs-content pre .fssnip code {
+ font: 0.86rem 'Roboto Mono', monospace;
+}
+
+#fsdocs-content table.pre,
+#fsdocs-content pre.fssnip,
+#fsdocs-content pre {
+ line-height: 13pt;
+ border: 0px solid #d8d8d8;
+ border-top: 0px solid #e3e3e3;
+ border-collapse: separate;
+ white-space: pre;
+ font: 0.86rem 'Roboto Mono', monospace;
+ width: 100%;
+ margin: 10px 0px 20px 0px;
+ background-color: #f3f4f7;
+ padding: 10px;
+ border-radius: 5px;
+ color: #8e0e2b;
+ max-width: none;
+ box-sizing: border-box;
+}
+
+#fsdocs-content pre.fssnip code {
+ font: 0.86rem 'Roboto Mono', monospace;
+ font-weight: 600;
+}
+
+#fsdocs-content table.pre {
+ background-color: #fff7ed;
+}
+
+#fsdocs-content table.pre pre {
+ padding: 0px;
+ margin: 0px;
+ border-radius: 0px;
+ width: 100%;
+ background-color: #fff7ed;
+ color: #837b79;
+}
+
+#fsdocs-content table.pre td {
+ padding: 0px;
+ white-space: normal;
+ margin: 0px;
+ width: 100%;
+}
+
+#fsdocs-content table.pre td.lines {
+ width: 30px;
+}
+
+
+#fsdocs-content pre {
+ word-wrap: inherit;
+}
+
+.fsdocs-example-header {
+ font-size: 1.0rem;
+ line-height: 1.375rem;
+ letter-spacing: 0.01px;
+ font-weight: 700;
+ color: #262626;
+}
+
+/*--------------------------------------------------------------------------
+ Formatting github source links
+/*--------------------------------------------------------------------------*/
+
+.fsdocs-source-link {
+ float: right;
+ text-decoration: none;
+}
+
+ .fsdocs-source-link img {
+ border-style: none;
+ margin-left: 10px;
+ width: auto;
+ height: 1.4em;
+ }
+
+ .fsdocs-source-link .hover {
+ display: none;
+ }
+
+ .fsdocs-source-link:hover .hover {
+ display: block;
+ }
+
+ .fsdocs-source-link .normal {
+ display: block;
+ }
+
+ .fsdocs-source-link:hover .normal {
+ display: none;
+ }
+
+/*--------------------------------------------------------------------------
+ Formatting logo
+/*--------------------------------------------------------------------------*/
+
+#fsdocs-logo {
+ width:140px;
+ height:140px;
+ margin:10px 0px 0px 0px;
+ border-style:none;
+}
+
+/*--------------------------------------------------------------------------
+
+/*--------------------------------------------------------------------------*/
+
+#fsdocs-content table.pre pre {
+ padding: 0px;
+ margin: 0px;
+ border: none;
+}
+
+/*--------------------------------------------------------------------------
+ Remove formatting from links
+/*--------------------------------------------------------------------------*/
+
+#fsdocs-content h1 a,
+#fsdocs-content h1 a:hover,
+#fsdocs-content h1 a:focus,
+#fsdocs-content h2 a,
+#fsdocs-content h2 a:hover,
+#fsdocs-content h2 a:focus,
+#fsdocs-content h3 a,
+#fsdocs-content h3 a:hover,
+#fsdocs-content h3 a:focus,
+#fsdocs-content h4 a,
+#fsdocs-content h4 a:hover, #fsdocs-content
+#fsdocs-content h4 a:focus,
+#fsdocs-content h5 a,
+#fsdocs-content h5 a:hover,
+#fsdocs-content h5 a:focus,
+#fsdocs-content h6 a,
+#fsdocs-content h6 a:hover,
+#fsdocs-content h6 a:focus {
+ color: #262626;
+ text-decoration: none;
+ text-decoration-style: none;
+ /* outline: none */
+}
+
+/*--------------------------------------------------------------------------
+ Formatting for F# code snippets
+/*--------------------------------------------------------------------------*/
+
+.fsdocs-param-name,
+.fsdocs-return-name,
+.fsdocs-param {
+ font-weight: 900;
+ font-size: 0.85rem;
+ font-family: 'Roboto Mono', monospace;
+}
+/* strings --- and stlyes for other string related formats */
+#fsdocs-content span.s {
+ color: #dd1144;
+}
+/* printf formatters */
+#fsdocs-content span.pf {
+ color: #E0C57F;
+}
+/* escaped chars */
+#fsdocs-content span.e {
+ color: #EA8675;
+}
+
+/* identifiers --- and styles for more specific identifier types */
+#fsdocs-content span.id {
+ color: #262626;
+}
+/* module */
+#fsdocs-content span.m {
+ color: #009999;
+}
+/* reference type */
+#fsdocs-content span.rt {
+ color: #4974D1;
+}
+/* value type */
+#fsdocs-content span.vt {
+ color: #43AEC6;
+}
+/* interface */
+#fsdocs-content span.if {
+ color: #43AEC6;
+}
+/* type argument */
+#fsdocs-content span.ta {
+ color: #43AEC6;
+}
+/* disposable */
+#fsdocs-content span.d {
+ color: #43AEC6;
+}
+/* property */
+#fsdocs-content span.prop {
+ color: #43AEC6;
+}
+/* punctuation */
+#fsdocs-content span.p {
+ color: #43AEC6;
+}
+#fsdocs-content span.pn {
+ color: #262626;
+}
+/* function */
+#fsdocs-content span.f {
+ color: #e1e1e1;
+}
+#fsdocs-content span.fn {
+ color: #990000;
+}
+/* active pattern */
+#fsdocs-content span.pat {
+ color: #4ec9b0;
+}
+/* union case */
+#fsdocs-content span.u {
+ color: #4ec9b0;
+}
+/* enumeration */
+#fsdocs-content span.e {
+ color: #4ec9b0;
+}
+/* keywords */
+#fsdocs-content span.k {
+ color: #b68015;
+ /* font-weight: bold; */
+}
+/* comment */
+#fsdocs-content span.c {
+ color: #808080;
+ font-weight: 400;
+ font-style: italic;
+}
+/* operators */
+#fsdocs-content span.o {
+ color: #af75c1;
+}
+/* numbers */
+#fsdocs-content span.n {
+ color: #009999;
+}
+/* line number */
+#fsdocs-content span.l {
+ color: #80b0b0;
+}
+/* mutable var or ref cell */
+#fsdocs-content span.v {
+ color: #d1d1d1;
+ font-weight: bold;
+}
+/* inactive code */
+#fsdocs-content span.inactive {
+ color: #808080;
+}
+/* preprocessor */
+#fsdocs-content span.prep {
+ color: #af75c1;
+}
+/* fsi output */
+#fsdocs-content span.fsi {
+ color: #808080;
+}
+
+/* tool tip */
+div.fsdocs-tip {
+ background: #475b5f;
+ border-radius: 4px;
+ font: 0.85rem 'Roboto Mono', monospace;
+ padding: 6px 8px 6px 8px;
+ display: none;
+ color: #d1d1d1;
+ pointer-events: none;
+}
+
+ div.fsdocs-tip code {
+ color: #d1d1d1;
+ font: 0.85rem 'Roboto Mono', monospace;
+ }
+
diff --git a/content/fsdocs-search.js b/content/fsdocs-search.js
new file mode 100644
index 000000000..3d543cf38
--- /dev/null
+++ b/content/fsdocs-search.js
@@ -0,0 +1,84 @@
+var lunrIndex, pagesIndex;
+
+function endsWith(str, suffix) {
+ return str.indexOf(suffix, str.length - suffix.length) !== -1;
+}
+
+// Initialize lunrjs using our generated index file
+function initLunr() {
+ if (!endsWith(fsdocs_search_baseurl,"/")){
+ fsdocs_search_baseurl = fsdocs_search_baseurl+'/'
+ };
+
+ // First retrieve the index file
+ $.getJSON(fsdocs_search_baseurl +"index.json")
+ .done(function(index) {
+ pagesIndex = index;
+ // Set up lunrjs by declaring the fields we use
+ // Also provide their boost level for the ranking
+ lunrIndex = lunr(function() {
+ this.ref("uri");
+ this.field('title', {
+ boost: 15
+ });
+ this.field('tags', {
+ boost: 10
+ });
+ this.field("content", {
+ boost: 5
+ });
+
+ this.pipeline.remove(lunr.stemmer);
+ this.searchPipeline.remove(lunr.stemmer);
+
+ // Feed lunr with each file and let lunr actually index them
+ pagesIndex.forEach(function(page) {
+ this.add(page);
+ }, this);
+ })
+ })
+ .fail(function(jqxhr, textStatus, error) {
+ var err = textStatus + ", " + error;
+ console.error("Error getting Hugo index file:", err);
+ });
+}
+
+/**
+ * Trigger a search in lunr and transform the result
+ *
+ * @param {String} query
+ * @return {Array} results
+ */
+function search(queryTerm) {
+ // Find the item in our index corresponding to the lunr one to have more info
+ return lunrIndex.search(queryTerm+"^100"+" "+queryTerm+"*^10"+" "+"*"+queryTerm+"^10"+" "+queryTerm+"~2^1").map(function(result) {
+ return pagesIndex.filter(function(page) {
+ return page.uri === result.ref;
+ })[0];
+ });
+}
+
+// Let's get started
+initLunr();
+
+$( document ).ready(function() {
+ var searchList = new autoComplete({
+ /* selector for the search box element */
+ minChars: 1,
+ selector: $("#search-by").get(0),
+ /* source is the callback to perform the search */
+ source: function(term, response) {
+ response(search(term));
+ },
+ /* renderItem displays individual search results */
+ renderItem: function(item, search) {
+ search = search.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+ var re = new RegExp("(" + search.split(' ').join('|') + ")", "gi");
+ return '' + item.title.replace(re, "$1") + '';
+ },
+ /* onSelect callback fires when a search suggestion is chosen */
+ onSelect: function(e, term, item) {
+ location.href = item.getAttribute('data-uri');
+ }
+ });
+});
diff --git a/content/fsdocs-tips.js b/content/fsdocs-tips.js
new file mode 100644
index 000000000..bcd04cb10
--- /dev/null
+++ b/content/fsdocs-tips.js
@@ -0,0 +1,54 @@
+var currentTip = null;
+var currentTipElement = null;
+
+function hideTip(evt, name, unique) {
+ var el = document.getElementById(name);
+ el.style.display = "none";
+ currentTip = null;
+}
+
+function findPos(obj) {
+ // no idea why, but it behaves differently in webbrowser component
+ if (window.location.search == "?inapp")
+ return [obj.offsetLeft + 10, obj.offsetTop + 30];
+
+ var curleft = 0;
+ var curtop = obj.offsetHeight;
+ while (obj) {
+ curleft += obj.offsetLeft;
+ curtop += obj.offsetTop;
+ obj = obj.offsetParent;
+ };
+ return [curleft, curtop];
+}
+
+function hideUsingEsc(e) {
+ if (!e) { e = event; }
+ hideTip(e, currentTipElement, currentTip);
+}
+
+function showTip(evt, name, unique, owner) {
+ document.onkeydown = hideUsingEsc;
+ if (currentTip == unique) return;
+ currentTip = unique;
+ currentTipElement = name;
+
+ var pos = findPos(owner ? owner : (evt.srcElement ? evt.srcElement : evt.target));
+ var posx = pos[0];
+ var posy = pos[1];
+
+ var el = document.getElementById(name);
+ var parent = (document.documentElement == null) ? document.body : document.documentElement;
+ el.style.position = "absolute";
+ el.style.left = posx + "px";
+ el.style.top = posy + "px";
+ el.style.display = "block";
+}
+function Clipboard_CopyTo(value) {
+ var tempInput = document.createElement("input");
+ tempInput.value = value;
+ document.body.appendChild(tempInput);
+ tempInput.select();
+ document.execCommand("copy");
+ document.body.removeChild(tempInput);
+}
\ No newline at end of file
diff --git a/content/img/copy-md-hover.png b/content/img/copy-md-hover.png
new file mode 100644
index 000000000..b14e94129
Binary files /dev/null and b/content/img/copy-md-hover.png differ
diff --git a/content/img/copy-md.png b/content/img/copy-md.png
new file mode 100644
index 000000000..72de73815
Binary files /dev/null and b/content/img/copy-md.png differ
diff --git a/content/img/copy-xml-hover.png b/content/img/copy-xml-hover.png
new file mode 100644
index 000000000..60fea167a
Binary files /dev/null and b/content/img/copy-xml-hover.png differ
diff --git a/content/img/copy-xml.png b/content/img/copy-xml.png
new file mode 100644
index 000000000..e5606b907
Binary files /dev/null and b/content/img/copy-xml.png differ
diff --git a/content/img/github-hover.png b/content/img/github-hover.png
new file mode 100644
index 000000000..65971d4d2
Binary files /dev/null and b/content/img/github-hover.png differ
diff --git a/content/img/github.png b/content/img/github.png
new file mode 100644
index 000000000..ff34f3540
Binary files /dev/null and b/content/img/github.png differ
diff --git a/content/navbar-fixed-left.css b/content/navbar-fixed-left.css
new file mode 100644
index 000000000..2de6255a8
--- /dev/null
+++ b/content/navbar-fixed-left.css
@@ -0,0 +1,77 @@
+body {
+ padding-top: 90px;
+}
+
+@media (min-width: 768px) {
+ body {
+ padding-top: 0;
+ }
+}
+
+@media (min-width: 768px) {
+ body {
+ margin-left: 252px;
+ }
+}
+.navbar {
+ overflow-y: auto;
+ overflow-x: hidden;
+ box-shadow: none;
+}
+.navbar.fixed-left {
+ position: fixed;
+ top: 0;
+ left: 0;
+ right: 0;
+ z-index: 1030;
+}
+.navbar-nav .nav-link {
+ padding-top: 0.3rem;
+ padding-bottom: 0.3rem;
+}
+
+@media (min-width: 768px) {
+ .navbar.fixed-left {
+ bottom: 0;
+ width: 252px;
+ flex-flow: column nowrap;
+ align-items: flex-start;
+ }
+
+ .navbar.fixed-left .navbar-collapse {
+ flex-grow: 0;
+ flex-direction: column;
+ width: 100%;
+ }
+
+ .navbar.fixed-left .navbar-collapse .navbar-nav {
+ flex-direction: column;
+ width: 100%;
+ }
+
+ .navbar.fixed-left .navbar-collapse .navbar-nav .nav-item {
+ width: 100%;
+ }
+
+ .navbar.fixed-left .navbar-collapse .navbar-nav .nav-item .dropdown-menu {
+ top: 0;
+ }
+}
+
+@media (min-width: 768px) {
+ .navbar.fixed-left {
+ right: auto;
+ }
+
+ .navbar.fixed-left .navbar-nav .nav-item .dropdown-toggle:after {
+ border-top: 0.3em solid transparent;
+ border-left: 0.3em solid;
+ border-bottom: 0.3em solid transparent;
+ border-right: none;
+ vertical-align: baseline;
+ }
+
+ .navbar.fixed-left .navbar-nav .nav-item .dropdown-menu {
+ left: 100%;
+ }
+}
diff --git a/content/navbar-fixed-right.css b/content/navbar-fixed-right.css
new file mode 100644
index 000000000..ad6cef83b
--- /dev/null
+++ b/content/navbar-fixed-right.css
@@ -0,0 +1,78 @@
+body {
+ padding-top: 90px;
+}
+
+@media (min-width: 768px) {
+ body {
+ padding-top: 0;
+ }
+}
+
+@media (min-width: 768px) {
+ body {
+ margin-right: 252px;
+ }
+}
+
+.navbar {
+ overflow-y: auto;
+ overflow-x: hidden;
+ box-shadow: none;
+}
+.navbar.fixed-right {
+ position: fixed;
+ top: 0;
+ left: 0;
+ right: 0;
+ z-index: 1030;
+}
+.navbar-nav .nav-link {
+ padding-top: 0.3rem;
+ padding-bottom: 0.3rem;
+}
+@media (min-width: 768px) {
+ .navbar.fixed-right {
+ bottom: 0;
+ width: 252px;
+ flex-flow: column nowrap;
+ align-items: flex-start;
+ }
+
+ .navbar.fixed-right .navbar-collapse {
+ flex-grow: 0;
+ flex-direction: column;
+ width: 100%;
+ }
+
+ .navbar.fixed-right .navbar-collapse .navbar-nav {
+ flex-direction: column;
+ width: 100%;
+ }
+
+ .navbar.fixed-right .navbar-collapse .navbar-nav .nav-item {
+ width: 100%;
+ }
+
+ .navbar.fixed-right .navbar-collapse .navbar-nav .nav-item .dropdown-menu {
+ top: 0;
+ }
+}
+
+@media (min-width: 768px) {
+ .navbar.fixed-right {
+ left: auto;
+ }
+
+ .navbar.fixed-right .navbar-nav .nav-item .dropdown-toggle:after {
+ border-top: 0.3em solid transparent;
+ border-left: none;
+ border-bottom: 0.3em solid transparent;
+ border-right: 0.3em solid;
+ vertical-align: baseline;
+ }
+
+ .navbar.fixed-right .navbar-nav .nav-item .dropdown-menu {
+ left: auto;
+ right: 100%;
+ }
+}
diff --git a/evaluation.fsx b/evaluation.fsx
new file mode 100644
index 000000000..e9e802938
--- /dev/null
+++ b/evaluation.fsx
@@ -0,0 +1,190 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,19.1.1"
+(**
+[](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`:
+
+ 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`:
+
+ [ 0 .. 99 ]
+
+ (*** include-it ***)
+
+
+To include the meta output of F# Interactive processing such as type signatures use `(*** include-fsi-output ***)`:
+
+ let test = 40 + 3
+
+ (*** include-fsi-output ***)
+
+To include both console otuput and F# Interactive output blended use `(*** include-fsi-merged-output ***)`.
+
+ let test = 40 + 4
+ (*** include-fsi-merged-output ***)
+
+You can use the same commands with a named snippet:
+
+ (*** include-it: test ***)
+ (*** include-fsi-output: test ***)
+ (*** include-output: test ***)
+
+You can use the `include-value` command to format a specific value:
+
+ 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:
+
+ (**
+ (*** 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:
+
+*)
+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:
+
+*)
+
+Formatting demo
+
+1:
+
+
+let test = ["one";"two";"three"]
+
+
+one
two
three
+
+
diff --git a/evaluation.html b/evaluation.html
new file mode 100644
index 000000000..692ffdae2
--- /dev/null
+++ b/evaluation.html
@@ -0,0 +1,394 @@
+
+
+
+
+
+ Embedding script output
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 and
+it is implemented using the F# Compiler service.
+Including Console Output
+To include the Console output use include-output:
+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:
+[ 0 .. 99 ]
+
+(*** include-it ***)
+
+To include the meta output of F# Interactive processing such as type signatures use (*** include-fsi-output ***):
+let test = 40 + 3
+
+(*** include-fsi-output ***)
+
+To include both console otuput and F# Interactive output blended use (*** include-fsi-merged-output ***).
+let test = 40 + 4
+(*** include-fsi-merged-output ***)
+
+You can use the same commands with a named snippet:
+(*** include-it: test ***)
+(*** include-fsi-output: test ***)
+(*** include-output: test ***)
+
+You can use the include-value command to format a specific value:
+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:
+(**
+ (*** 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.
+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:
+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 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 <ol>.
+This can be done by calling FsiEvaluator.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<list<_>> then
+ let items =
+ // Get items as objects and create paragraph for each item
+ [ for it in Seq.cast<obj> (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:
+
+Formatting demo
+
+1:
+
+
+let test = ["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>
--------------------
new: ?options: string array * ?fsiObj: obj * ?addHtmlPrinter: bool * ?discardStdOut: bool * ?disableFsiObj: bool * ?onError: (string -> unit) -> FsiEvaluator
+val doc: LiterateDocument
+type Literate =
+ static member ConvertMarkdownFile: input: string * ?template: string * ?output: string * ?outputKind: OutputKind * ?prefix: string * ?fscOptions: string * ?lineNumbers: bool * ?references: bool * ?substitutions: (ParamKey * string) list * ?generateAnchors: bool * ?imageSaver: (string -> string) * ?rootInputFolder: string * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?onError: (string -> unit) * ?filesWithFrontMatter: FrontMatterFile array -> unit
+ static member ConvertScriptFile: input: string * ?template: string * ?output: string * ?outputKind: OutputKind * ?prefix: string * ?fscOptions: string * ?lineNumbers: bool * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?substitutions: (ParamKey * string) list * ?generateAnchors: bool * ?imageSaver: (string -> string) * ?rootInputFolder: string * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?onError: (string -> unit) * ?filesWithFrontMatter: FrontMatterFile array -> unit
+ static member ParseAndCheckScriptFile: path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ParseMarkdownFile: path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ParseMarkdownString: content: string * ?path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ParseScriptString: content: string * ?path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ToFsx: doc: LiterateDocument * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member ToHtml: doc: LiterateDocument * ?prefix: string * ?lineNumbers: bool * ?generateAnchors: bool * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?tokenKindToCss: (TokenKind -> string) -> string
+ static member ToLatex: doc: LiterateDocument * ?prefix: string * ?lineNumbers: bool * ?generateAnchors: bool * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member ToPynb: doc: LiterateDocument * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ ...
<summary>
+ This type provides three simple methods for calling the literate programming tool.
+ The <c>ConvertMarkdownFile</c> and <c>ConvertScriptFile</c> methods process a single Markdown document
+ and F# script, respectively. The <c>ConvertDirectory</c> method handles an entire directory tree
+ (looking for <c>*.fsx</c> and <c>*.md</c> files).
+ </summary>
<namespacedoc><summary>Functionality to support literate programming for F# scripts</summary></namespacedoc>
+static member Literate.ParseScriptString: content: string * ?path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+static member Literate.ToHtml: doc: LiterateDocument * ?prefix: string * ?lineNumbers: bool * ?generateAnchors: bool * ?substitutions: (FSharp.Formatting.Templating.ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?tokenKindToCss: (FSharp.Formatting.CodeFormat.TokenKind -> string) -> string
+val fsiEvaluator: FsiEvaluator
+member FsiEvaluator.RegisterTransformation: f: (obj * System.Type * int -> MarkdownParagraph list option) -> unit
+val o: obj
+val ty: System.Type
+val _executionCount: int
+property System.Type.IsGenericType: bool with get
+System.Type.GetGenericTypeDefinition() : System.Type
+val typedefof<'T> : System.Type
+type 'T list = List<'T>
+val items: MarkdownParagraph list list
+val it: obj
+module Seq
+
+from Microsoft.FSharp.Collections
+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>
+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..60ffbf097
--- /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,19.1.1\"\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:
+
+
+let test = ["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:
+
+
+let test = ["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..e9a1074b8
--- /dev/null
+++ b/index.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+ F# Formatting: Documentation Tools for F# Code
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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 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 - explains the content expected in the docs directory for the fsdocs tool.
Using the Command line tool - explains how to use the fsdocs tool.
-
+
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!
+
+
+Using FSharp.Formatting as a library
+F# Formatting is also available on NuGet as a set of libraries.
+
+-
+
Markdown parser - explains the F# Markdown
+processor that is available in this library with some basic examples of
+document processing.
+
+-
+
F# code formatting - 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.
+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..64207953a
--- /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"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common.html","title":"FSharp.Formatting.Common","content":"Menu"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate.html","title":"FSharp.Formatting.Literate","content":"MarkdownPatterns \nLiterate \nLiterateCodeOptions \nLiterateCodeVisibility \nLiterateDocument \nLiterateParagraph \nLiterateParagraphOptions \nLiterateSource \nOutputKind"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating.html","title":"FSharp.Formatting.Templating","content":"ParamKeys \nFrontMatterFile \nParamKey \nSubstitutions"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html","title":"ApiDocAttribute","content":"ApiDocAttribute \n\n Represents a custom attribute attached to source code\n \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.ConstructorArguments \nConstructorArguments \nApiDocAttribute.NamedConstructorArguments \nNamedConstructorArguments \nApiDocAttribute.Name \nName \nApiDocAttribute.IsCustomOperationAttribute \nIsCustomOperationAttribute \nApiDocAttribute.FullName \nFullName \nApiDocAttribute.CustomOperationName \nCustomOperationName \nApiDocAttribute.IsObsoleteAttribute \nIsObsoleteAttribute \nApiDocAttribute.ObsoleteMessage \nObsoleteMessage \nApiDocAttribute.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#Format","title":"ApiDocAttribute.Format","content":"ApiDocAttribute.Format \nFormat \n\n Formats the attribute using the Name. Removes the \u0022Attribute\u0022-suffix. E.g Obsolete\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FormatFullName","title":"ApiDocAttribute.FormatFullName","content":"ApiDocAttribute.FormatFullName \nFormatFullName \n\n Formats the attribute using the FullName. Removes the \u0022Attribute\u0022-suffix. E.g System.Obsolete\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FormatFullNameLongForm","title":"ApiDocAttribute.FormatFullNameLongForm","content":"ApiDocAttribute.FormatFullNameLongForm \nFormatFullNameLongForm \n\n Formats the attribute using the FullName. Keeps the \u0022Attribute\u0022-suffix. E.g System.ObsoleteAttribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FormatLongForm","title":"ApiDocAttribute.FormatLongForm","content":"ApiDocAttribute.FormatLongForm \nFormatLongForm \n\n Formats the attribute using the Name. Keeps the \u0022Attribute\u0022-suffix. E.g ObsoleteAttribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#ConstructorArguments","title":"ApiDocAttribute.ConstructorArguments","content":"ApiDocAttribute.ConstructorArguments \nConstructorArguments \n\n The arguments to the constructor for the attribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#NamedConstructorArguments","title":"ApiDocAttribute.NamedConstructorArguments","content":"ApiDocAttribute.NamedConstructorArguments \nNamedConstructorArguments \n\n The named arguments for the attribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#Name","title":"ApiDocAttribute.Name","content":"ApiDocAttribute.Name \nName \n\n The name of the attribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#IsCustomOperationAttribute","title":"ApiDocAttribute.IsCustomOperationAttribute","content":"ApiDocAttribute.IsCustomOperationAttribute \nIsCustomOperationAttribute \n\n Gets a value indicating whether this attribute the CustomOperationAttribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#FullName","title":"ApiDocAttribute.FullName","content":"ApiDocAttribute.FullName \nFullName \n\n The qualified name of the attribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#CustomOperationName","title":"ApiDocAttribute.CustomOperationName","content":"ApiDocAttribute.CustomOperationName \nCustomOperationName \n\n Returns the custom operation name, when this attribute is the CustomOperationAttribute. When its not an empty string is returned\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#IsObsoleteAttribute","title":"ApiDocAttribute.IsObsoleteAttribute","content":"ApiDocAttribute.IsObsoleteAttribute \nIsObsoleteAttribute \n\n Gets a value indicating whether this attribute is System.ObsoleteAttribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#ObsoleteMessage","title":"ApiDocAttribute.ObsoleteMessage","content":"ApiDocAttribute.ObsoleteMessage \nObsoleteMessage \n\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\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocattribute.html#IsRequireQualifiedAccessAttribute","title":"ApiDocAttribute.IsRequireQualifiedAccessAttribute","content":"ApiDocAttribute.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \n\n Gets a value indicating whether this attribute is RequireQualifiedAccessAttribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html","title":"ApiDocCollection","content":"ApiDocCollection \n\n Represents a group of assemblies integrated with its associated documentation\n \nApiDocCollection.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocCollection.Assemblies \nAssemblies \nApiDocCollection.Namespaces \nNamespaces \nApiDocCollection.CollectionName \nCollectionName"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#Assemblies","title":"ApiDocCollection.Assemblies","content":"ApiDocCollection.Assemblies \nAssemblies \n\n All assemblies in the collection\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#Namespaces","title":"ApiDocCollection.Namespaces","content":"ApiDocCollection.Namespaces \nNamespaces \n\n All namespaces in the collection\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccollection.html#CollectionName","title":"ApiDocCollection.CollectionName","content":"ApiDocCollection.CollectionName \nCollectionName \n\n Name of the collection\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html","title":"ApiDocComment","content":"ApiDocComment \n\n Represents a documentation comment attached to source code\n \nApiDocComment.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocComment.RawData \nRawData \nApiDocComment.Notes \nNotes \nApiDocComment.Xml \nXml \nApiDocComment.Summary \nSummary \nApiDocComment.Parameters \nParameters \nApiDocComment.Remarks \nRemarks \nApiDocComment.Exceptions \nExceptions \nApiDocComment.Returns \nReturns \nApiDocComment.Examples \nExamples"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#RawData","title":"ApiDocComment.RawData","content":"ApiDocComment.RawData \nRawData \n\n The raw data of the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Notes","title":"ApiDocComment.Notes","content":"ApiDocComment.Notes \nNotes \n\n The notes sections of the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Xml","title":"ApiDocComment.Xml","content":"ApiDocComment.Xml \nXml \n\n The XElement for the XML doc if available\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Summary","title":"ApiDocComment.Summary","content":"ApiDocComment.Summary \nSummary \n\n The summary for the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Parameters","title":"ApiDocComment.Parameters","content":"ApiDocComment.Parameters \nParameters \n\n The param sections of the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Remarks","title":"ApiDocComment.Remarks","content":"ApiDocComment.Remarks \nRemarks \n\n The remarks html for comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Exceptions","title":"ApiDocComment.Exceptions","content":"ApiDocComment.Exceptions \nExceptions \n\n The notes sections of the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Returns","title":"ApiDocComment.Returns","content":"ApiDocComment.Returns \nReturns \n\n The return sections of the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoccomment.html#Examples","title":"ApiDocComment.Examples","content":"ApiDocComment.Examples \nExamples \n\n The examples sections of the comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html","title":"ApiDocEntity","content":"ApiDocEntity \n\n Represents a type definition integrated with its associated documentation\n \nApiDocEntity.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocEntity.OutputFile \nOutputFile \nApiDocEntity.Url \nUrl \nApiDocEntity.Attributes \nAttributes \nApiDocEntity.Exclude \nExclude \nApiDocEntity.IsObsolete \nIsObsolete \nApiDocEntity.ActivePatterns \nActivePatterns \nApiDocEntity.ObsoleteMessage \nObsoleteMessage \nApiDocEntity.StaticParameters \nStaticParameters \nApiDocEntity.AllMembers \nAllMembers \nApiDocEntity.UrlBaseName \nUrlBaseName \nApiDocEntity.DelegateSignature \nDelegateSignature \nApiDocEntity.ValuesAndFuncs \nValuesAndFuncs \nApiDocEntity.RecordFields \nRecordFields \nApiDocEntity.IsTypeDefinition \nIsTypeDefinition \nApiDocEntity.AllInterfaces \nAllInterfaces \nApiDocEntity.CategoryIndex \nCategoryIndex \nApiDocEntity.Name \nName \nApiDocEntity.SourceLocation \nSourceLocation \nApiDocEntity.Assembly \nAssembly \nApiDocEntity.Category \nCategory \nApiDocEntity.UnionCases \nUnionCases \nApiDocEntity.Symbol \nSymbol \nApiDocEntity.InstanceMembers \nInstanceMembers \nApiDocEntity.RequiresQualifiedAccess \nRequiresQualifiedAccess \nApiDocEntity.TypeExtensions \nTypeExtensions \nApiDocEntity.AbbreviatedType \nAbbreviatedType \nApiDocEntity.StaticMembers \nStaticMembers \nApiDocEntity.Comment \nComment \nApiDocEntity.NestedEntities \nNestedEntities \nApiDocEntity.BaseType \nBaseType \nApiDocEntity.Substitutions \nSubstitutions \nApiDocEntity.Constructors \nConstructors \nApiDocEntity.GetUrl \nGetUrl"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#OutputFile","title":"ApiDocEntity.OutputFile","content":"ApiDocEntity.OutputFile \nOutputFile \n\n The name of the file generated for this entity\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Url","title":"ApiDocEntity.Url","content":"ApiDocEntity.Url \nUrl \n\n The URL of the best link for the entity relative to \u0022reference\u0022 directory (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Attributes","title":"ApiDocEntity.Attributes","content":"ApiDocEntity.Attributes \nAttributes \n\n The declared attributes of the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Exclude","title":"ApiDocEntity.Exclude","content":"ApiDocEntity.Exclude \nExclude \n\n The exclude flag\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#IsObsolete","title":"ApiDocEntity.IsObsolete","content":"ApiDocEntity.IsObsolete \nIsObsolete \n\n Gets a value indicating whether this member is obsolete\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#ActivePatterns","title":"ApiDocEntity.ActivePatterns","content":"ApiDocEntity.ActivePatterns \nActivePatterns \n\n Active patterns of the module\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#ObsoleteMessage","title":"ApiDocEntity.ObsoleteMessage","content":"ApiDocEntity.ObsoleteMessage \nObsoleteMessage \n\n Returns the obsolete message, when this member is obsolete. When its not or no message was specified, an empty string is returned\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#StaticParameters","title":"ApiDocEntity.StaticParameters","content":"ApiDocEntity.StaticParameters \nStaticParameters \n\n Static parameters\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#AllMembers","title":"ApiDocEntity.AllMembers","content":"ApiDocEntity.AllMembers \nAllMembers \n\n All members of the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#UrlBaseName","title":"ApiDocEntity.UrlBaseName","content":"ApiDocEntity.UrlBaseName \nUrlBaseName \n\n The URL base name of the primary documentation for the entity (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#DelegateSignature","title":"ApiDocEntity.DelegateSignature","content":"ApiDocEntity.DelegateSignature \nDelegateSignature \n\n If this is a delegate, then e formatted signature\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#ValuesAndFuncs","title":"ApiDocEntity.ValuesAndFuncs","content":"ApiDocEntity.ValuesAndFuncs \nValuesAndFuncs \n\n Values and functions of the module\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#RecordFields","title":"ApiDocEntity.RecordFields","content":"ApiDocEntity.RecordFields \nRecordFields \n\n The fields of a record type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#IsTypeDefinition","title":"ApiDocEntity.IsTypeDefinition","content":"ApiDocEntity.IsTypeDefinition \nIsTypeDefinition \n\n Indicates if the entity is a type definition\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#AllInterfaces","title":"ApiDocEntity.AllInterfaces","content":"ApiDocEntity.AllInterfaces \nAllInterfaces \n\n All interfaces of the type, formatted\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#CategoryIndex","title":"ApiDocEntity.CategoryIndex","content":"ApiDocEntity.CategoryIndex \nCategoryIndex \n\n The category index of the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Name","title":"ApiDocEntity.Name","content":"ApiDocEntity.Name \nName \n\n The name of the entity\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#SourceLocation","title":"ApiDocEntity.SourceLocation","content":"ApiDocEntity.SourceLocation \nSourceLocation \n\n The URL of the member\u0027s source location, if any\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Assembly","title":"ApiDocEntity.Assembly","content":"ApiDocEntity.Assembly \nAssembly \n\n The name of the type\u0027s assembly\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Category","title":"ApiDocEntity.Category","content":"ApiDocEntity.Category \nCategory \n\n The category of the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#UnionCases","title":"ApiDocEntity.UnionCases","content":"ApiDocEntity.UnionCases \nUnionCases \n\n The cases of a union type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Symbol","title":"ApiDocEntity.Symbol","content":"ApiDocEntity.Symbol \nSymbol \n\n The F# compiler symbol for the type definition\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#InstanceMembers","title":"ApiDocEntity.InstanceMembers","content":"ApiDocEntity.InstanceMembers \nInstanceMembers \n\n The instance members of the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#RequiresQualifiedAccess","title":"ApiDocEntity.RequiresQualifiedAccess","content":"ApiDocEntity.RequiresQualifiedAccess \nRequiresQualifiedAccess \n\n Does the module have the RequiresQualifiedAccess attribute\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#TypeExtensions","title":"ApiDocEntity.TypeExtensions","content":"ApiDocEntity.TypeExtensions \nTypeExtensions \n\n Type extensions of the module\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#AbbreviatedType","title":"ApiDocEntity.AbbreviatedType","content":"ApiDocEntity.AbbreviatedType \nAbbreviatedType \n\n If this is a type abbreviation, then the abbreviated type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#StaticMembers","title":"ApiDocEntity.StaticMembers","content":"ApiDocEntity.StaticMembers \nStaticMembers \n\n The static members of the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Comment","title":"ApiDocEntity.Comment","content":"ApiDocEntity.Comment \nComment \n\n The attached comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#NestedEntities","title":"ApiDocEntity.NestedEntities","content":"ApiDocEntity.NestedEntities \nNestedEntities \n\n All nested modules and types\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#BaseType","title":"ApiDocEntity.BaseType","content":"ApiDocEntity.BaseType \nBaseType \n\n The base type of the type, formatted\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Substitutions","title":"ApiDocEntity.Substitutions","content":"ApiDocEntity.Substitutions \nSubstitutions \n\n The substitution parameters active for generating thist content\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#Constructors","title":"ApiDocEntity.Constructors","content":"ApiDocEntity.Constructors \nConstructors \n\n The constuctorsof the type\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentity.html#GetUrl","title":"ApiDocEntity.GetUrl","content":"ApiDocEntity.GetUrl \nGetUrl \n\n Compute the URL of the best link for the entity relative to \u0022reference\u0022 directory (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html","title":"ApiDocEntityInfo","content":"ApiDocEntityInfo \n\n High-level information about a module definition\n \nApiDocEntityInfo.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocEntityInfo.Entity \nEntity \nApiDocEntityInfo.Namespace \nNamespace \nApiDocEntityInfo.Collection \nCollection \nApiDocEntityInfo.ParentModule \nParentModule"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#Entity","title":"ApiDocEntityInfo.Entity","content":"ApiDocEntityInfo.Entity \nEntity \n\n The actual entity\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#Namespace","title":"ApiDocEntityInfo.Namespace","content":"ApiDocEntityInfo.Namespace \nNamespace \n\n The namespace the entity belongs to\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#Collection","title":"ApiDocEntityInfo.Collection","content":"ApiDocEntityInfo.Collection \nCollection \n\n The collection of assemblies the entity belongs to\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocentityinfo.html#ParentModule","title":"ApiDocEntityInfo.ParentModule","content":"ApiDocEntityInfo.ParentModule \nParentModule \n\n The parent module, if any.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocfileextensions.html","title":"ApiDocFileExtensions","content":"ApiDocFileExtensions \n \nApiDocFileExtensions.InFile \nInFile \nApiDocFileExtensions.InUrl \nInUrl"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocfileextensions.html#InFile","title":"ApiDocFileExtensions.InFile","content":"ApiDocFileExtensions.InFile \nInFile \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocfileextensions.html#InUrl","title":"ApiDocFileExtensions.InUrl","content":"ApiDocFileExtensions.InUrl \nInUrl \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html","title":"ApiDocHtml","content":"ApiDocHtml \n\n Represents some HTML formatted by model generation\n \nApiDocHtml.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocHtml.Id \nId \nApiDocHtml.HtmlText \nHtmlText"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html#Id","title":"ApiDocHtml.Id","content":"ApiDocHtml.Id \nId \n\n Get the Id of the element when rendered to html, if any\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidochtml.html#HtmlText","title":"ApiDocHtml.HtmlText","content":"ApiDocHtml.HtmlText \nHtmlText \n\n Get the HTML text of the HTML section\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html","title":"ApiDocInput","content":"ApiDocInput \n\n Represents an input assembly for API doc generation\n \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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#FromFile","title":"ApiDocInput.FromFile","content":"ApiDocInput.FromFile \nFromFile \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#Path","title":"ApiDocInput.Path","content":"ApiDocInput.Path \nPath \n\n The path to the assembly\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#XmlFile","title":"ApiDocInput.XmlFile","content":"ApiDocInput.XmlFile \nXmlFile \n\n Override the default XML file (normally assumed to live alongside)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#SourceFolder","title":"ApiDocInput.SourceFolder","content":"ApiDocInput.SourceFolder \nSourceFolder \n\n The compile-time source folder\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#SourceRepo","title":"ApiDocInput.SourceRepo","content":"ApiDocInput.SourceRepo \nSourceRepo \n\n The URL the the source repo where the source code lives\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#Substitutions","title":"ApiDocInput.Substitutions","content":"ApiDocInput.Substitutions \nSubstitutions \n\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.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#MarkdownComments","title":"ApiDocInput.MarkdownComments","content":"ApiDocInput.MarkdownComments \nMarkdownComments \n\n Whether the input uses markdown comments\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#Warn","title":"ApiDocInput.Warn","content":"ApiDocInput.Warn \nWarn \n\n Whether doc processing should warn on missing comments\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocinput.html#PublicOnly","title":"ApiDocInput.PublicOnly","content":"ApiDocInput.PublicOnly \nPublicOnly \n\n Whether to generate only public things\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html","title":"ApiDocMember","content":"ApiDocMember \n\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.\n \nApiDocMember.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocMember.Url \nUrl \nApiDocMember.Comment \nComment \nApiDocMember.FormatModifiers \nFormatModifiers \nApiDocMember.UsageHtml \nUsageHtml \nApiDocMember.IsObsolete \nIsObsolete \nApiDocMember.TypeArguments \nTypeArguments \nApiDocMember.Name \nName \nApiDocMember.Exclude \nExclude \nApiDocMember.Symbol \nSymbol \nApiDocMember.ExtendedType \nExtendedType \nApiDocMember.Category \nCategory \nApiDocMember.Modifiers \nModifiers \nApiDocMember.Attributes \nAttributes \nApiDocMember.Kind \nKind \nApiDocMember.Details \nDetails \nApiDocMember.Parameters \nParameters \nApiDocMember.CustomOperationName \nCustomOperationName \nApiDocMember.CompiledName \nCompiledName \nApiDocMember.UrlBaseName \nUrlBaseName \nApiDocMember.CategoryIndex \nCategoryIndex \nApiDocMember.FormatCompiledName \nFormatCompiledName \nApiDocMember.ReturnInfo \nReturnInfo \nApiDocMember.FormatTypeArguments \nFormatTypeArguments \nApiDocMember.SourceLocation \nSourceLocation \nApiDocMember.ObsoleteMessage \nObsoleteMessage \nApiDocMember.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \nApiDocMember.GetUrl \nGetUrl"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Url","title":"ApiDocMember.Url","content":"ApiDocMember.Url \nUrl \n\n The URL of the best link documentation for the item relative to \u0022reference\u0022 directory (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Comment","title":"ApiDocMember.Comment","content":"ApiDocMember.Comment \nComment \n\n The attached comment\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#FormatModifiers","title":"ApiDocMember.FormatModifiers","content":"ApiDocMember.FormatModifiers \nFormatModifiers \n\n Formats modifiers\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#UsageHtml","title":"ApiDocMember.UsageHtml","content":"ApiDocMember.UsageHtml \nUsageHtml \n\n The usage section in a typical tooltip\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#IsObsolete","title":"ApiDocMember.IsObsolete","content":"ApiDocMember.IsObsolete \nIsObsolete \n\n Gets a value indicating whether this member is obsolete\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#TypeArguments","title":"ApiDocMember.TypeArguments","content":"ApiDocMember.TypeArguments \nTypeArguments \n\n The member\u0027s type arguments\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Name","title":"ApiDocMember.Name","content":"ApiDocMember.Name \nName \n\n Name of the member\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Exclude","title":"ApiDocMember.Exclude","content":"ApiDocMember.Exclude \nExclude \n\n The exclude flag\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Symbol","title":"ApiDocMember.Symbol","content":"ApiDocMember.Symbol \nSymbol \n\n The symbol this member is related to\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#ExtendedType","title":"ApiDocMember.ExtendedType","content":"ApiDocMember.ExtendedType \nExtendedType \n\n The type extended by an extension member, if any\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Category","title":"ApiDocMember.Category","content":"ApiDocMember.Category \nCategory \n\n The category\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Modifiers","title":"ApiDocMember.Modifiers","content":"ApiDocMember.Modifiers \nModifiers \n\n The member\u0027s modifiers\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Attributes","title":"ApiDocMember.Attributes","content":"ApiDocMember.Attributes \nAttributes \n\n The declared attributes of the member\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Kind","title":"ApiDocMember.Kind","content":"ApiDocMember.Kind \nKind \n\n The kind of the member\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Details","title":"ApiDocMember.Details","content":"ApiDocMember.Details \nDetails \n\n The members details\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#Parameters","title":"ApiDocMember.Parameters","content":"ApiDocMember.Parameters \nParameters \n\n The member\u0027s parameters and associated documentation\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#CustomOperationName","title":"ApiDocMember.CustomOperationName","content":"ApiDocMember.CustomOperationName \nCustomOperationName \n\n Returns the custom operation name, when this attribute is the CustomOperationAttribute.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#CompiledName","title":"ApiDocMember.CompiledName","content":"ApiDocMember.CompiledName \nCompiledName \n\n The member\u0027s compiled name, if any\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#UrlBaseName","title":"ApiDocMember.UrlBaseName","content":"ApiDocMember.UrlBaseName \nUrlBaseName \n\n The URL base name of the best link documentation for the item (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#CategoryIndex","title":"ApiDocMember.CategoryIndex","content":"ApiDocMember.CategoryIndex \nCategoryIndex \n\n The category index\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#FormatCompiledName","title":"ApiDocMember.FormatCompiledName","content":"ApiDocMember.FormatCompiledName \nFormatCompiledName \n\n Formats the compiled name\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#ReturnInfo","title":"ApiDocMember.ReturnInfo","content":"ApiDocMember.ReturnInfo \nReturnInfo \n\n The return section in a typical tooltip\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#FormatTypeArguments","title":"ApiDocMember.FormatTypeArguments","content":"ApiDocMember.FormatTypeArguments \nFormatTypeArguments \n\n Formats type arguments\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#SourceLocation","title":"ApiDocMember.SourceLocation","content":"ApiDocMember.SourceLocation \nSourceLocation \n\n The URL of the member\u0027s source location, if any\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#ObsoleteMessage","title":"ApiDocMember.ObsoleteMessage","content":"ApiDocMember.ObsoleteMessage \nObsoleteMessage \n\n Returns the obsolete message, when this member is obsolete. When its not or no message was specified, an empty string is returned\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#IsRequireQualifiedAccessAttribute","title":"ApiDocMember.IsRequireQualifiedAccessAttribute","content":"ApiDocMember.IsRequireQualifiedAccessAttribute \nIsRequireQualifiedAccessAttribute \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmember.html#GetUrl","title":"ApiDocMember.GetUrl","content":"ApiDocMember.GetUrl \nGetUrl \n\n The URL of the best link documentation for the item relative to \u0022reference\u0022 directory (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberdetails.html","title":"ApiDocMemberDetails","content":"ApiDocMemberDetails \n \nApiDocMemberDetails.ApiDocMemberDetails \nApiDocMemberDetails"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberdetails.html#ApiDocMemberDetails","title":"ApiDocMemberDetails.ApiDocMemberDetails","content":"ApiDocMemberDetails.ApiDocMemberDetails \nApiDocMemberDetails \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html","title":"ApiDocMemberKind","content":"ApiDocMemberKind \n\n Represents the kind of member\n \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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#ValueOrFunction","title":"ApiDocMemberKind.ValueOrFunction","content":"ApiDocMemberKind.ValueOrFunction \nValueOrFunction \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#TypeExtension","title":"ApiDocMemberKind.TypeExtension","content":"ApiDocMemberKind.TypeExtension \nTypeExtension \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#ActivePattern","title":"ApiDocMemberKind.ActivePattern","content":"ApiDocMemberKind.ActivePattern \nActivePattern \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#Constructor","title":"ApiDocMemberKind.Constructor","content":"ApiDocMemberKind.Constructor \nConstructor \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#InstanceMember","title":"ApiDocMemberKind.InstanceMember","content":"ApiDocMemberKind.InstanceMember \nInstanceMember \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#StaticMember","title":"ApiDocMemberKind.StaticMember","content":"ApiDocMemberKind.StaticMember \nStaticMember \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#UnionCase","title":"ApiDocMemberKind.UnionCase","content":"ApiDocMemberKind.UnionCase \nUnionCase \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#RecordField","title":"ApiDocMemberKind.RecordField","content":"ApiDocMemberKind.RecordField \nRecordField \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmemberkind.html#StaticParameter","title":"ApiDocMemberKind.StaticParameter","content":"ApiDocMemberKind.StaticParameter \nStaticParameter \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html","title":"ApiDocModel","content":"ApiDocModel \n\n Represents a set of assemblies integrated with their associated documentation\n \nApiDocModel.IndexFileUrl \nIndexFileUrl \nApiDocModel.IndexOutputFile \nIndexOutputFile \nApiDocModel.Qualify \nQualify \nApiDocModel.FileExtensions \nFileExtensions \nApiDocModel.EntityInfos \nEntityInfos \nApiDocModel.Root \nRoot \nApiDocModel.Substitutions \nSubstitutions \nApiDocModel.Collection \nCollection"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#IndexFileUrl","title":"ApiDocModel.IndexFileUrl","content":"ApiDocModel.IndexFileUrl \nIndexFileUrl \n\n URL of the \u0027index.html\u0027 for the reference documentation for the model\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#IndexOutputFile","title":"ApiDocModel.IndexOutputFile","content":"ApiDocModel.IndexOutputFile \nIndexOutputFile \n\n URL of the \u0027index.html\u0027 for the reference documentation for the model\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Qualify","title":"ApiDocModel.Qualify","content":"ApiDocModel.Qualify \nQualify \n\n Indicates if each collection is being qualified by its collection name, e.g. \u0027reference/FSharp.Core\u0027\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#FileExtensions","title":"ApiDocModel.FileExtensions","content":"ApiDocModel.FileExtensions \nFileExtensions \n\n Specifies file extensions to use in files and URLs\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#EntityInfos","title":"ApiDocModel.EntityInfos","content":"ApiDocModel.EntityInfos \nEntityInfos \n\n The full list of all entities\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Root","title":"ApiDocModel.Root","content":"ApiDocModel.Root \nRoot \n\n The root URL for the entire generation, normally \u0027/\u0027\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Substitutions","title":"ApiDocModel.Substitutions","content":"ApiDocModel.Substitutions \nSubstitutions \n\n The substitutions. Different substitutions can also be used for each specific input\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocmodel.html#Collection","title":"ApiDocModel.Collection","content":"ApiDocModel.Collection \nCollection \n\n The full list of all entities\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html","title":"ApiDocNamespace","content":"ApiDocNamespace \n\n Represents a namespace integrated with its associated documentation\n \nApiDocNamespace.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nApiDocNamespace.OutputFile \nOutputFile \nApiDocNamespace.Url \nUrl \nApiDocNamespace.Name \nName \nApiDocNamespace.UrlHash \nUrlHash \nApiDocNamespace.UrlBaseName \nUrlBaseName \nApiDocNamespace.Substitutions \nSubstitutions \nApiDocNamespace.Entities \nEntities \nApiDocNamespace.NamespaceDocs \nNamespaceDocs"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#OutputFile","title":"ApiDocNamespace.OutputFile","content":"ApiDocNamespace.OutputFile \nOutputFile \n\n The name of the file generated for this entity\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Url","title":"ApiDocNamespace.Url","content":"ApiDocNamespace.Url \nUrl \n\n The URL of the best link documentation for the item (without the http://site.io/reference)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Name","title":"ApiDocNamespace.Name","content":"ApiDocNamespace.Name \nName \n\n The name of the namespace\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#UrlHash","title":"ApiDocNamespace.UrlHash","content":"ApiDocNamespace.UrlHash \nUrlHash \n\n The hash label for the URL with the overall namespaces file\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#UrlBaseName","title":"ApiDocNamespace.UrlBaseName","content":"ApiDocNamespace.UrlBaseName \nUrlBaseName \n\n The base name for the generated file\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Substitutions","title":"ApiDocNamespace.Substitutions","content":"ApiDocNamespace.Substitutions \nSubstitutions \n\n The substitution substitutions active for generating thist content\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#Entities","title":"ApiDocNamespace.Entities","content":"ApiDocNamespace.Entities \nEntities \n\n All modules in the namespace\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocnamespace.html#NamespaceDocs","title":"ApiDocNamespace.NamespaceDocs","content":"ApiDocNamespace.NamespaceDocs \nNamespaceDocs \n\n The summary text for the namespace\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidoctype.html","title":"ApiDocType","content":"ApiDocType \n"},{"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"},{"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 "},{"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 "},{"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 "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html","title":"ApiDocsSearchIndexEntry","content":"ApiDocsSearchIndexEntry \n\n Represents an entry suitable for constructing a Lunr index\n \nApiDocsSearchIndexEntry.uri \nuri \nApiDocsSearchIndexEntry.title \ntitle \nApiDocsSearchIndexEntry.content \ncontent"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#uri","title":"ApiDocsSearchIndexEntry.uri","content":"ApiDocsSearchIndexEntry.uri \nuri \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#title","title":"ApiDocsSearchIndexEntry.title","content":"ApiDocsSearchIndexEntry.title \ntitle \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html#content","title":"ApiDocsSearchIndexEntry.content","content":"ApiDocsSearchIndexEntry.content \ncontent \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-attribute.html","title":"Attribute","content":"Attribute \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-doccomment.html","title":"DocComment","content":"DocComment \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-member.html","title":"Member","content":"Member \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-memberkind.html","title":"MemberKind","content":"MemberKind \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-module.html","title":"Module","content":"Module \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-moduleinfo.html","title":"ModuleInfo","content":"ModuleInfo \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-type.html","title":"Type","content":"Type \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-apidocs-typeinfo.html","title":"TypeInfo","content":"TypeInfo \n"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-clikeformat.html#CommentRegEx","title":"CLikeFormat.CommentRegEx","content":"CLikeFormat.CommentRegEx \nCommentRegEx \n\n Regular expression string to match single line and multi-line \n comments (// and /* */). \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-clikeformat.html#StringRegEx","title":"CLikeFormat.StringRegEx","content":"CLikeFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string and character literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html","title":"CPlusPlusFormat","content":"CPlusPlusFormat \n\n Generates color-coded HTML 4.01 from C\u002B\u002B source code.\n \nCPlusPlusFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCPlusPlusFormat.Keywords \nKeywords \nCPlusPlusFormat.Preprocessors \nPreprocessors"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html#Keywords","title":"CPlusPlusFormat.Keywords","content":"CPlusPlusFormat.Keywords \nKeywords \n\n The list of C\u002B\u002B keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-cplusplusformat.html#Preprocessors","title":"CPlusPlusFormat.Preprocessors","content":"CPlusPlusFormat.Preprocessors \nPreprocessors \n\n The list of C\u002B\u002B preprocessors.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html","title":"CSharpFormat","content":"CSharpFormat \n\n Generates color-coded HTML 4.01 from C# source code.\n \nCSharpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCSharpFormat.Keywords \nKeywords \nCSharpFormat.Preprocessors \nPreprocessors \nCSharpFormat.Operators \nOperators"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#Keywords","title":"CSharpFormat.Keywords","content":"CSharpFormat.Keywords \nKeywords \n\n The list of C# keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#Preprocessors","title":"CSharpFormat.Preprocessors","content":"CSharpFormat.Preprocessors \nPreprocessors \n\n The list of C# preprocessors.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-csharpformat.html#Operators","title":"CSharpFormat.Operators","content":"CSharpFormat.Operators \nOperators \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html","title":"CodeFormat","content":"CodeFormat \n\n Provides a base class for formatting most programming languages.\n \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"},{"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"},{"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 "},{"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 "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#StringRegEx","title":"CodeFormat.StringRegEx","content":"CodeFormat.StringRegEx \nStringRegEx \n\n Must be overridden to provide a regular expression string\n to match strings literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#CommentRegEx","title":"CodeFormat.CommentRegEx","content":"CodeFormat.CommentRegEx \nCommentRegEx \n\n Must be overridden to provide a regular expression string\n to match comments. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-codeformat.html#NumberRegEx","title":"CodeFormat.NumberRegEx","content":"CodeFormat.NumberRegEx \nNumberRegEx \n\n Can be overridden to provide a list of tokes to be recognized as numbers.\n "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html","title":"FSharpFormat","content":"FSharpFormat \n\n Generates color-coded HTML 4.01 from F# source code.\n \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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#Operators","title":"FSharpFormat.Operators","content":"FSharpFormat.Operators \nOperators \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#CommentRegEx","title":"FSharpFormat.CommentRegEx","content":"FSharpFormat.CommentRegEx \nCommentRegEx \n\n Regular expression string to match single line and multi-line \n comments (// and (* *)). \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#Keywords","title":"FSharpFormat.Keywords","content":"FSharpFormat.Keywords \nKeywords \n\n The list of F# keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#StringRegEx","title":"FSharpFormat.StringRegEx","content":"FSharpFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string and character literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-fsharpformat.html#Preprocessors","title":"FSharpFormat.Preprocessors","content":"FSharpFormat.Preprocessors \nPreprocessors \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html","title":"HaskellFormat","content":"HaskellFormat \n\n Generates color-coded HTML 4.01 from MSH (code name Monad) source code.\n \nHaskellFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nHaskellFormat.CommentRegEx \nCommentRegEx \nHaskellFormat.StringRegEx \nStringRegEx \nHaskellFormat.Keywords \nKeywords \nHaskellFormat.Preprocessors \nPreprocessors"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#CommentRegEx","title":"HaskellFormat.CommentRegEx","content":"HaskellFormat.CommentRegEx \nCommentRegEx \n\n Regular expression string to match single line comments (#).\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#StringRegEx","title":"HaskellFormat.StringRegEx","content":"HaskellFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string and character literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#Keywords","title":"HaskellFormat.Keywords","content":"HaskellFormat.Keywords \nKeywords \n\n The list of MSH keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-haskellformat.html#Preprocessors","title":"HaskellFormat.Preprocessors","content":"HaskellFormat.Preprocessors \nPreprocessors \n\n Use preprocessors property to hilight operators.\n "},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html","title":"JavaScriptFormat","content":"JavaScriptFormat \n\n Generates color-coded HTML 4.01 from JavaSctript source code.\n \nJavaScriptFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nJavaScriptFormat.Keywords \nKeywords \nJavaScriptFormat.Preprocessors \nPreprocessors \nJavaScriptFormat.Operators \nOperators"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#Keywords","title":"JavaScriptFormat.Keywords","content":"JavaScriptFormat.Keywords \nKeywords \n\n The list of JavaScript keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#Preprocessors","title":"JavaScriptFormat.Preprocessors","content":"JavaScriptFormat.Preprocessors \nPreprocessors \n\n Use the pre-processor color to mark directives that start with @.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-javascriptformat.html#Operators","title":"JavaScriptFormat.Operators","content":"JavaScriptFormat.Operators \nOperators \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html","title":"MshFormat","content":"MshFormat \n\n Generates color-coded HTML 4.01 from MSH (code name Monad) source code.\n \nMshFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nMshFormat.CommentRegEx \nCommentRegEx \nMshFormat.StringRegEx \nStringRegEx \nMshFormat.Keywords \nKeywords \nMshFormat.Preprocessors \nPreprocessors"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#CommentRegEx","title":"MshFormat.CommentRegEx","content":"MshFormat.CommentRegEx \nCommentRegEx \n\n Regular expression string to match single line comments (#).\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#StringRegEx","title":"MshFormat.StringRegEx","content":"MshFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string and character literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#Keywords","title":"MshFormat.Keywords","content":"MshFormat.Keywords \nKeywords \n\n The list of MSH keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-mshformat.html#Preprocessors","title":"MshFormat.Preprocessors","content":"MshFormat.Preprocessors \nPreprocessors \n\n Use preprocessors property to hilight operators.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html","title":"PaketFormat","content":"PaketFormat \n\n Generates color-coded Paket source code.\n \nPaketFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nPaketFormat.CommentRegEx \nCommentRegEx \nPaketFormat.Operators \nOperators \nPaketFormat.Keywords \nKeywords \nPaketFormat.NumberRegEx \nNumberRegEx"},{"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\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#CommentRegEx","title":"PaketFormat.CommentRegEx","content":"PaketFormat.CommentRegEx \nCommentRegEx \n\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\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#Operators","title":"PaketFormat.Operators","content":"PaketFormat.Operators \nOperators \n\n Paket operators\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#Keywords","title":"PaketFormat.Keywords","content":"PaketFormat.Keywords \nKeywords \n\n Paket Keywords\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-paketformat.html#NumberRegEx","title":"PaketFormat.NumberRegEx","content":"PaketFormat.NumberRegEx \nNumberRegEx \n\n Matches version numbers\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html","title":"PhpFormat","content":"PhpFormat \n\n Generates color-coded HTML 4.01 from PHP source code.\n \nPhpFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nPhpFormat.StringRegEx \nStringRegEx \nPhpFormat.Keywords \nKeywords \nPhpFormat.Preprocessors \nPreprocessors"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#StringRegEx","title":"PhpFormat.StringRegEx","content":"PhpFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string and character literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#Keywords","title":"PhpFormat.Keywords","content":"PhpFormat.Keywords \nKeywords \n\n The list of PHP keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-phpformat.html#Preprocessors","title":"PhpFormat.Preprocessors","content":"PhpFormat.Preprocessors \nPreprocessors \n\n The list of PHP preprocessors.\n "},{"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"},{"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"},{"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 "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#FormatSubCode","title":"SourceFormat.FormatSubCode","content":"SourceFormat.FormatSubCode \nFormatSubCode \n\n Allows formatting a part of the code in a different language,\n for example a JavaScript block inside an HTML file.\n "},{"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 "},{"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 "},{"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 "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#CodeRegex","title":"SourceFormat.CodeRegex","content":"SourceFormat.CodeRegex \nCodeRegex \n\n The regular expression used to capture language tokens.\n "},{"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 "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-sourceformat.html#EscapeHtml","title":"SourceFormat.EscapeHtml","content":"SourceFormat.EscapeHtml \nEscapeHtml \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html","title":"SyntaxHighlighter","content":"SyntaxHighlighter \n\n Summary description for SyntaxHighlighter\n \nSyntaxHighlighter.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nSyntaxHighlighter.FormatHtml \nFormatHtml \nSyntaxHighlighter.FormatCode \nFormatCode"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html#FormatHtml","title":"SyntaxHighlighter.FormatHtml","content":"SyntaxHighlighter.FormatHtml \nFormatHtml \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html#FormatCode","title":"SyntaxHighlighter.FormatCode","content":"SyntaxHighlighter.FormatCode \nFormatCode \n\n TBD\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html","title":"TsqlFormat","content":"TsqlFormat \n\n Generates color-coded T-SQL source code.\n \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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#CommentRegEx","title":"TsqlFormat.CommentRegEx","content":"TsqlFormat.CommentRegEx \nCommentRegEx \n\n Regular expression string to match single line \n comments (--). \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#StringRegEx","title":"TsqlFormat.StringRegEx","content":"TsqlFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string literals. \n "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#Keywords","title":"TsqlFormat.Keywords","content":"TsqlFormat.Keywords \nKeywords \n\n The list of T-SQL keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-tsqlformat.html#Preprocessors","title":"TsqlFormat.Preprocessors","content":"TsqlFormat.Preprocessors \nPreprocessors \n\n Use the pre-processor color to mark keywords that start with @@.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-typescriptformat.html","title":"TypeScriptFormat","content":"TypeScriptFormat \n\n Generates color-coded HTML 4.01 from TypeScript source code.\n \nTypeScriptFormat.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTypeScriptFormat.Keywords \nKeywords"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-typescriptformat.html#Keywords","title":"TypeScriptFormat.Keywords","content":"TypeScriptFormat.Keywords \nKeywords \n\n The list of TypeScript keywords extends the ones from JavaScript.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html","title":"VisualBasicFormat","content":"VisualBasicFormat \n\n Generates color-coded HTML 4.01 from Visual Basic source code.\n \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"},{"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"},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#CommentRegEx","title":"VisualBasicFormat.CommentRegEx","content":"VisualBasicFormat.CommentRegEx \nCommentRegEx \n\n Regular expression string to match comments (\u0027 and REM). \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#StringRegEx","title":"VisualBasicFormat.StringRegEx","content":"VisualBasicFormat.StringRegEx \nStringRegEx \n\n Regular expression string to match string and character literals. \n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#Keywords","title":"VisualBasicFormat.Keywords","content":"VisualBasicFormat.Keywords \nKeywords \n\n The list of VB keywords.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-csharpformat-visualbasicformat.html#Preprocessors","title":"VisualBasicFormat.Preprocessors","content":"VisualBasicFormat.Preprocessors \nPreprocessors \n\n The list of VB preprocessors.\n "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html","title":"CodeFormatter","content":"CodeFormatter \n\n Uses agent to handle formatting requests\n \nCodeFormatter.processDoubleBackticks \nprocessDoubleBackticks \nCodeFormatter.categoryToTokenKind \ncategoryToTokenKind \nCodeFormatter.processSnippetLine \nprocessSnippetLine \nCodeFormatter.processSnippet \nprocessSnippet \nCodeFormatter.fsChecker \nfsChecker \nCodeFormatter.processSourceCode \nprocessSourceCode \nCodeFormatter.ParseAndCheckSource \nParseAndCheckSource"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processDoubleBackticks","title":"CodeFormatter.processDoubleBackticks","content":"CodeFormatter.processDoubleBackticks \nprocessDoubleBackticks \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#categoryToTokenKind","title":"CodeFormatter.categoryToTokenKind","content":"CodeFormatter.categoryToTokenKind \ncategoryToTokenKind \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processSnippetLine","title":"CodeFormatter.processSnippetLine","content":"CodeFormatter.processSnippetLine \nprocessSnippetLine \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processSnippet","title":"CodeFormatter.processSnippet","content":"CodeFormatter.processSnippet \nprocessSnippet \n\n Process snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#fsChecker","title":"CodeFormatter.fsChecker","content":"CodeFormatter.fsChecker \nfsChecker \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#processSourceCode","title":"CodeFormatter.processSourceCode","content":"CodeFormatter.processSourceCode \nprocessSourceCode \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformatter.html#ParseAndCheckSource","title":"CodeFormatter.ParseAndCheckSource","content":"CodeFormatter.ParseAndCheckSource \nParseAndCheckSource \n\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\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html","title":"CodeFormat","content":"CodeFormat \n\n Exposes functionality of the F# code formatter with a nice interface\n \nCodeFormat.FormatFsx \nFormatFsx \nCodeFormat.FormatHtml \nFormatHtml \nCodeFormat.FormatLatex \nFormatLatex"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatFsx","title":"CodeFormat.FormatFsx","content":"CodeFormat.FormatFsx \nFormatFsx \n\n Formats the .fsx snippets as iPython notebook using the default settings.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatHtml","title":"CodeFormat.FormatHtml","content":"CodeFormat.FormatHtml \nFormatHtml \n\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.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-codeformat.html#FormatLatex","title":"CodeFormat.FormatLatex","content":"CodeFormat.FormatLatex \nFormatLatex \n\n Formats the .fsx snippets as LaTeX. The parameters specify prefix for LaTeX tags, whether lines should\n be added to outputs.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-errorkind.html","title":"ErrorKind","content":"ErrorKind \n\n Represents a kind of error reported from the F# compiler (warning or error)\n \nErrorKind.Error \nError \nErrorKind.Warning \nWarning"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-errorkind.html#Error","title":"ErrorKind.Error","content":"ErrorKind.Error \nError \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-errorkind.html#Warning","title":"ErrorKind.Warning","content":"ErrorKind.Warning \nWarning \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html","title":"FormattedContent","content":"FormattedContent \n\n Represents formatted snippets\n \nFormattedContent.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFormattedContent.ToolTip \nToolTip \nFormattedContent.Snippets \nSnippets"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html#ToolTip","title":"FormattedContent.ToolTip","content":"FormattedContent.ToolTip \nToolTip \n\n Returns string with ToolTip elements for all the snippets\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedcontent.html#Snippets","title":"FormattedContent.Snippets","content":"FormattedContent.Snippets \nSnippets \n\n Returns the processed snippets as an array\n"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#Title","title":"FormattedSnippet.Title","content":"FormattedSnippet.Title \nTitle \n\n Returns the title of the snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#Key","title":"FormattedSnippet.Key","content":"FormattedSnippet.Key \nKey \n\n Returns the key of the snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-formattedsnippet.html#Content","title":"FormattedSnippet.Content","content":"FormattedSnippet.Content \nContent \n\n Returns the formatted content code for the snipet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-line.html","title":"Line","content":"Line \n\n Represents a line of source code as a list of TokenSpan values. This is\n a single case discriminated union with Line constructor.\n \nLine.Line \nLine"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-line.html#Line","title":"Line.Line","content":"Line.Line \nLine \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-snippet.html","title":"Snippet","content":"Snippet \n\n An F# snippet consists of a snippet title and a list of lines\n \nSnippet.Snippet \nSnippet"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-snippet.html#Snippet","title":"Snippet.Snippet","content":"Snippet.Snippet \nSnippet \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-sourceerror.html","title":"SourceError","content":"SourceError \n\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)\n \nSourceError.SourceError \nSourceError"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-sourceerror.html#SourceError","title":"SourceError.SourceError","content":"SourceError.SourceError \nSourceError \n\n Error reported from the F# compiler consists of location (start and end),\n error kind and the message\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html","title":"TokenKind","content":"TokenKind \n\n Classifies tokens reported by the FCS\n \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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Keyword","title":"TokenKind.Keyword","content":"TokenKind.Keyword \nKeyword \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#String","title":"TokenKind.String","content":"TokenKind.String \nString \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Comment","title":"TokenKind.Comment","content":"TokenKind.Comment \nComment \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Identifier","title":"TokenKind.Identifier","content":"TokenKind.Identifier \nIdentifier \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Inactive","title":"TokenKind.Inactive","content":"TokenKind.Inactive \nInactive \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Number","title":"TokenKind.Number","content":"TokenKind.Number \nNumber \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Operator","title":"TokenKind.Operator","content":"TokenKind.Operator \nOperator \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Punctuation","title":"TokenKind.Punctuation","content":"TokenKind.Punctuation \nPunctuation \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Preprocessor","title":"TokenKind.Preprocessor","content":"TokenKind.Preprocessor \nPreprocessor \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Module","title":"TokenKind.Module","content":"TokenKind.Module \nModule \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#ReferenceType","title":"TokenKind.ReferenceType","content":"TokenKind.ReferenceType \nReferenceType \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#ValueType","title":"TokenKind.ValueType","content":"TokenKind.ValueType \nValueType \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Interface","title":"TokenKind.Interface","content":"TokenKind.Interface \nInterface \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#TypeArgument","title":"TokenKind.TypeArgument","content":"TokenKind.TypeArgument \nTypeArgument \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Property","title":"TokenKind.Property","content":"TokenKind.Property \nProperty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Enumeration","title":"TokenKind.Enumeration","content":"TokenKind.Enumeration \nEnumeration \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#UnionCase","title":"TokenKind.UnionCase","content":"TokenKind.UnionCase \nUnionCase \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Function","title":"TokenKind.Function","content":"TokenKind.Function \nFunction \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Pattern","title":"TokenKind.Pattern","content":"TokenKind.Pattern \nPattern \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#MutableVar","title":"TokenKind.MutableVar","content":"TokenKind.MutableVar \nMutableVar \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Disposable","title":"TokenKind.Disposable","content":"TokenKind.Disposable \nDisposable \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Printf","title":"TokenKind.Printf","content":"TokenKind.Printf \nPrintf \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Escaped","title":"TokenKind.Escaped","content":"TokenKind.Escaped \nEscaped \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenkind.html#Default","title":"TokenKind.Default","content":"TokenKind.Default \nDefault \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html","title":"TokenSpan","content":"TokenSpan \n\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\n \nTokenSpan.Token \nToken \nTokenSpan.Error \nError \nTokenSpan.Omitted \nOmitted \nTokenSpan.Output \nOutput"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Token","title":"TokenSpan.Token","content":"TokenSpan.Token \nToken \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Error","title":"TokenSpan.Error","content":"TokenSpan.Error \nError \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Omitted","title":"TokenSpan.Omitted","content":"TokenSpan.Omitted \nOmitted \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspan.html#Output","title":"TokenSpan.Output","content":"TokenSpan.Output \nOutput \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html","title":"TokenSpans","content":"TokenSpans \n\n A type alias representing a list of TokenSpan values\n \nTokenSpans.Length \nLength \nTokenSpans.IsEmpty \nIsEmpty \nTokenSpans.Head \nHead \nTokenSpans.Tail \nTail \nTokenSpans.Item \nItem \nTokenSpans.Empty \nEmpty"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Length","title":"TokenSpans.Length","content":"TokenSpans.Length \nLength \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#IsEmpty","title":"TokenSpans.IsEmpty","content":"TokenSpans.IsEmpty \nIsEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Head","title":"TokenSpans.Head","content":"TokenSpans.Head \nHead \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Tail","title":"TokenSpans.Tail","content":"TokenSpans.Tail \nTail \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Item","title":"TokenSpans.Item","content":"TokenSpans.Item \nItem \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tokenspans.html#Empty","title":"TokenSpans.Empty","content":"TokenSpans.Empty \nEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html","title":"ToolTipSpan","content":"ToolTipSpan \n\n A tool tip span can be emphasized text, plain text Literal or a line brak\n \nToolTipSpan.Emphasis \nEmphasis \nToolTipSpan.Literal \nLiteral \nToolTipSpan.HardLineBreak \nHardLineBreak"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html#Emphasis","title":"ToolTipSpan.Emphasis","content":"ToolTipSpan.Emphasis \nEmphasis \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html#Literal","title":"ToolTipSpan.Literal","content":"ToolTipSpan.Literal \nLiteral \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspan.html#HardLineBreak","title":"ToolTipSpan.HardLineBreak","content":"ToolTipSpan.HardLineBreak \nHardLineBreak \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html","title":"ToolTipSpans","content":"ToolTipSpans \n\n A tool tip consists of a list of items reported from the compiler\n \nToolTipSpans.Length \nLength \nToolTipSpans.IsEmpty \nIsEmpty \nToolTipSpans.Head \nHead \nToolTipSpans.Tail \nTail \nToolTipSpans.Item \nItem \nToolTipSpans.Empty \nEmpty"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Length","title":"ToolTipSpans.Length","content":"ToolTipSpans.Length \nLength \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#IsEmpty","title":"ToolTipSpans.IsEmpty","content":"ToolTipSpans.IsEmpty \nIsEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Head","title":"ToolTipSpans.Head","content":"ToolTipSpans.Head \nHead \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Tail","title":"ToolTipSpans.Tail","content":"ToolTipSpans.Tail \nTail \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Item","title":"ToolTipSpans.Item","content":"ToolTipSpans.Item \nItem \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-codeformat-tooltipspans.html#Empty","title":"ToolTipSpans.Empty","content":"ToolTipSpans.Empty \nEmpty \n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html#createMenu","title":"Menu.createMenu","content":"Menu.createMenu \ncreateMenu \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html#isTemplatingAvailable","title":"Menu.isTemplatingAvailable","content":"Menu.isTemplatingAvailable \nisTemplatingAvailable \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu.html#getLastWriteTimes","title":"Menu.getLastWriteTimes","content":"Menu.getLastWriteTimes \ngetLastWriteTimes \n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu-menuitem.html#Link","title":"MenuItem.Link","content":"MenuItem.Link \nLink \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-common-menu-menuitem.html#Content","title":"MenuItem.Content","content":"MenuItem.Content \nContent \n"},{"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|_|)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-markdownpatterns.html#(|LiterateParagraph|_|)","title":"MarkdownPatterns.(|LiterateParagraph|_|)","content":"MarkdownPatterns.(|LiterateParagraph|_|) \n(|LiterateParagraph|_|) \n"},{"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.ParseScriptString \nParseScriptString \nLiterate.ToFsx \nToFsx \nLiterate.ToHtml \nToHtml \nLiterate.ToLatex \nToLatex \nLiterate.ToPynb \nToPynb \nLiterate.WriteHtml \nWriteHtml \nLiterate.WriteLatex \nWriteLatex"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ConvertMarkdownFile","title":"Literate.ConvertMarkdownFile","content":"Literate.ConvertMarkdownFile \nConvertMarkdownFile \n\n Convert a markdown file into HTML or another output kind\n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParseAndCheckScriptFile","title":"Literate.ParseAndCheckScriptFile","content":"Literate.ParseAndCheckScriptFile \nParseAndCheckScriptFile \n\n Parse F# Script file to LiterateDocument\n"},{"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 "},{"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 "},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ParseScriptString","title":"Literate.ParseScriptString","content":"Literate.ParseScriptString \nParseScriptString \n\n Parse string as F# Script to LiterateDocument\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToFsx","title":"Literate.ToFsx","content":"Literate.ToFsx \nToFsx \n\n Formate the literate document as an .fsx script\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToHtml","title":"Literate.ToHtml","content":"Literate.ToHtml \nToHtml \n\n Format the literate document as HTML without using a template\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToLatex","title":"Literate.ToLatex","content":"Literate.ToLatex \nToLatex \n\n Format the literate document as Latex without using a template\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#ToPynb","title":"Literate.ToPynb","content":"Literate.ToPynb \nToPynb \n\n Formate the literate document as an iPython notebook\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#WriteHtml","title":"Literate.WriteHtml","content":"Literate.WriteHtml \nWriteHtml \n\n Write the literate document as HTML without using a template\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literate.html#WriteLatex","title":"Literate.WriteLatex","content":"Literate.WriteLatex \nWriteLatex \n\n Write the literate document as Latex without using a template\n"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#OutputName","title":"LiterateCodeOptions.OutputName","content":"LiterateCodeOptions.OutputName \nOutputName \n\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.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#ExecutionCount","title":"LiterateCodeOptions.ExecutionCount","content":"LiterateCodeOptions.ExecutionCount \nExecutionCount \n\n Indiciates the execution sequence number of the cell if it has been evaluated\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodeoptions.html#Visibility","title":"LiterateCodeOptions.Visibility","content":"LiterateCodeOptions.Visibility \nVisibility \n\n Specifies the visibility of the snippet in the generated HTML\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html","title":"LiterateCodeVisibility","content":"LiterateCodeVisibility \n\n Specifies visibility of a code snippet.\n \nLiterateCodeVisibility.VisibleCode \nVisibleCode \nLiterateCodeVisibility.HiddenCode \nHiddenCode \nLiterateCodeVisibility.NamedCode \nNamedCode"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html#VisibleCode","title":"LiterateCodeVisibility.VisibleCode","content":"LiterateCodeVisibility.VisibleCode \nVisibleCode \n\n Ordinary visible code\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html#HiddenCode","title":"LiterateCodeVisibility.HiddenCode","content":"LiterateCodeVisibility.HiddenCode \nHiddenCode \n\n Hidden snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatecodevisibility.html#NamedCode","title":"LiterateCodeVisibility.NamedCode","content":"LiterateCodeVisibility.NamedCode \nNamedCode \n\n Named snippet with captured output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html","title":"LiterateDocument","content":"LiterateDocument \n\n Representation of a literate document - the representation of Paragraphs\n uses an F# discriminated union type and so is best used from F#.\n \nLiterateDocument.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nLiterateDocument.With \nWith \nLiterateDocument.DefinedLinks \nDefinedLinks \nLiterateDocument.Source \nSource \nLiterateDocument.Diagnostics \nDiagnostics \nLiterateDocument.RootInputFolder \nRootInputFolder \nLiterateDocument.SourceFile \nSourceFile \nLiterateDocument.MarkdownDocument \nMarkdownDocument \nLiterateDocument.FormattedTips \nFormattedTips \nLiterateDocument.Paragraphs \nParagraphs"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#With","title":"LiterateDocument.With","content":"LiterateDocument.With \nWith \n\n Clone the document and change some of its properties\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#DefinedLinks","title":"LiterateDocument.DefinedLinks","content":"LiterateDocument.DefinedLinks \nDefinedLinks \n\n Returns a dictionary containing explicitly defined links\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#Source","title":"LiterateDocument.Source","content":"LiterateDocument.Source \nSource \n\n Original document source code\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#Diagnostics","title":"LiterateDocument.Diagnostics","content":"LiterateDocument.Diagnostics \nDiagnostics \n\n Errors\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#RootInputFolder","title":"LiterateDocument.RootInputFolder","content":"LiterateDocument.RootInputFolder \nRootInputFolder \n\n Root for computing relative paths\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#SourceFile","title":"LiterateDocument.SourceFile","content":"LiterateDocument.SourceFile \nSourceFile \n\n Location where the file was loaded from\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#MarkdownDocument","title":"LiterateDocument.MarkdownDocument","content":"LiterateDocument.MarkdownDocument \nMarkdownDocument \n\n Return as markdown document, throwing away additional stuff\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#FormattedTips","title":"LiterateDocument.FormattedTips","content":"LiterateDocument.FormattedTips \nFormattedTips \n\n Formatted tool tips\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatedocument.html#Paragraphs","title":"LiterateDocument.Paragraphs","content":"LiterateDocument.Paragraphs \nParagraphs \n\n Returns a list of paragraphs in the document\n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ParagraphOptions","title":"LiterateParagraph.ParagraphOptions","content":"LiterateParagraph.ParagraphOptions \nParagraphOptions \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#CodeReference","title":"LiterateParagraph.CodeReference","content":"LiterateParagraph.CodeReference \nCodeReference \n\n (*** include:foo ***) - Include formatted snippet from other part of the document here\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#FsiOutputReference","title":"LiterateParagraph.FsiOutputReference","content":"LiterateParagraph.FsiOutputReference \nFsiOutputReference \n\n (*** include-fsi-output ***) - Include output from previous snippet\n (*** include-fsi-output:foo ***) - Include output from a named snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#FsiMergedOutputReference","title":"LiterateParagraph.FsiMergedOutputReference","content":"LiterateParagraph.FsiMergedOutputReference \nFsiMergedOutputReference \n\n (*** include-fsi-merged-output ***) - Include output from previous snippet\n (*** include-fsi-merged-output:foo ***) - Include output from a named snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#OutputReference","title":"LiterateParagraph.OutputReference","content":"LiterateParagraph.OutputReference \nOutputReference \n\n (*** include-fsi-output ***) - Include F# Interactive output from previous snippet\n (*** include-fsi-output:foo ***) - Include F# Interactive from a named snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ItValueReference","title":"LiterateParagraph.ItValueReference","content":"LiterateParagraph.ItValueReference \nItValueReference \n\n (*** include-it ***) - Include \u0022it\u0022 value from the subsequent snippet here\n (*** include-it:foo ***) - Include \u0022it\u0022 value from a named snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ItRawReference","title":"LiterateParagraph.ItRawReference","content":"LiterateParagraph.ItRawReference \nItRawReference \n\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)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#ValueReference","title":"LiterateParagraph.ValueReference","content":"LiterateParagraph.ValueReference \nValueReference \n\n (*** include-value:foo ***) - Include the formatting of a specified value here\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#LiterateCode","title":"LiterateParagraph.LiterateCode","content":"LiterateParagraph.LiterateCode \nLiterateCode \n\n Emebdded literate code snippet. Consists of source lines and options\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#LanguageTaggedCode","title":"LiterateParagraph.LanguageTaggedCode","content":"LiterateParagraph.LanguageTaggedCode \nLanguageTaggedCode \n\n Ordinary formatted code snippet in non-F# language (tagged with language code)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraph.html#RawBlock","title":"LiterateParagraph.RawBlock","content":"LiterateParagraph.RawBlock \nRawBlock \n\n Block simply emitted without any formatting equivalent to \u003Cpre\u003E tag in html\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraphoptions.html","title":"LiterateParagraphOptions","content":"LiterateParagraphOptions \n\n Specifies the options for a literate paragraph\n \nLiterateParagraphOptions.Condition \nCondition"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literateparagraphoptions.html#Condition","title":"LiterateParagraphOptions.Condition","content":"LiterateParagraphOptions.Condition \nCondition \n\n Specifies a conditional for inclusion of the snippet paragraph\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatesource.html","title":"LiterateSource","content":"LiterateSource \n\n Represents the source of a literate document.\n \nLiterateSource.Markdown \nMarkdown \nLiterateSource.Script \nScript"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatesource.html#Markdown","title":"LiterateSource.Markdown","content":"LiterateSource.Markdown \nMarkdown \n\n A markdown source\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-literatesource.html#Script","title":"LiterateSource.Script","content":"LiterateSource.Script \nScript \n\n A parsed F# script file consisting of snippets.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html","title":"OutputKind","content":"OutputKind \n\n Defines the possible output types from literate script (HTML, Latex, Pynb)\n \nOutputKind.Extension \nExtension \nOutputKind.Html \nHtml \nOutputKind.Latex \nLatex \nOutputKind.Pynb \nPynb \nOutputKind.Fsx \nFsx \nOutputKind.Markdown \nMarkdown"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Extension","title":"OutputKind.Extension","content":"OutputKind.Extension \nExtension \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Html","title":"OutputKind.Html","content":"OutputKind.Html \nHtml \n\n Requests HTML output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Latex","title":"OutputKind.Latex","content":"OutputKind.Latex \nLatex \n\n Requests LaTeX output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Pynb","title":"OutputKind.Pynb","content":"OutputKind.Pynb \nPynb \n\n Requests Notebook output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Fsx","title":"OutputKind.Fsx","content":"OutputKind.Fsx \nFsx \n\n Requests F# Script output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-outputkind.html#Markdown","title":"OutputKind.Markdown","content":"OutputKind.Markdown \nMarkdown \n\n Requests Markdown output\n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#FsiOutput","title":"FsiEmbedKind.FsiOutput","content":"FsiEmbedKind.FsiOutput \nFsiOutput \n\n The FSI output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#FsiMergedOutput","title":"FsiEmbedKind.FsiMergedOutput","content":"FsiEmbedKind.FsiMergedOutput \nFsiMergedOutput \n\n The combined FSI output and console output\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#ConsoleOutput","title":"FsiEmbedKind.ConsoleOutput","content":"FsiEmbedKind.ConsoleOutput \nConsoleOutput \n\n The stdout from this part of the execution (not including FSI output)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#ItValue","title":"FsiEmbedKind.ItValue","content":"FsiEmbedKind.ItValue \nItValue \n\n The \u0027it\u0027 value\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#ItRaw","title":"FsiEmbedKind.ItRaw","content":"FsiEmbedKind.ItRaw \nItRaw \n\n The \u0027it\u0027 value as raw text\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html#Value","title":"FsiEmbedKind.Value","content":"FsiEmbedKind.Value \nValue \n\n A specific value\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html","title":"FsiEvaluationFailedInfo","content":"FsiEvaluationFailedInfo \n\n Record that is reported by the EvaluationFailed event when something\n goes wrong during evalutaiton of an expression\n \nFsiEvaluationFailedInfo.Text \nText \nFsiEvaluationFailedInfo.AsExpression \nAsExpression \nFsiEvaluationFailedInfo.File \nFile \nFsiEvaluationFailedInfo.Exception \nException \nFsiEvaluationFailedInfo.StdErr \nStdErr"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#Text","title":"FsiEvaluationFailedInfo.Text","content":"FsiEvaluationFailedInfo.Text \nText \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#AsExpression","title":"FsiEvaluationFailedInfo.AsExpression","content":"FsiEvaluationFailedInfo.AsExpression \nAsExpression \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#File","title":"FsiEvaluationFailedInfo.File","content":"FsiEvaluationFailedInfo.File \nFile \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#Exception","title":"FsiEvaluationFailedInfo.Exception","content":"FsiEvaluationFailedInfo.Exception \nException \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html#StdErr","title":"FsiEvaluationFailedInfo.StdErr","content":"FsiEvaluationFailedInfo.StdErr \nStdErr \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html","title":"FsiEvaluationResult","content":"FsiEvaluationResult \n\n Represents the result of evaluating an F# snippet. This contains\n the generated console output together with a result and its static type.\n \nFsiEvaluationResult.Output \nOutput \nFsiEvaluationResult.FsiOutput \nFsiOutput \nFsiEvaluationResult.FsiMergedOutput \nFsiMergedOutput \nFsiEvaluationResult.ItValue \nItValue \nFsiEvaluationResult.Result \nResult"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#Output","title":"FsiEvaluationResult.Output","content":"FsiEvaluationResult.Output \nOutput \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#FsiOutput","title":"FsiEvaluationResult.FsiOutput","content":"FsiEvaluationResult.FsiOutput \nFsiOutput \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#FsiMergedOutput","title":"FsiEvaluationResult.FsiMergedOutput","content":"FsiEvaluationResult.FsiMergedOutput \nFsiMergedOutput \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#ItValue","title":"FsiEvaluationResult.ItValue","content":"FsiEvaluationResult.ItValue \nItValue \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html#Result","title":"FsiEvaluationResult.Result","content":"FsiEvaluationResult.Result \nResult \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html","title":"FsiEvaluator","content":"FsiEvaluator \n\n A wrapper for F# interactive service that is used to evaluate inline snippets\n \nFsiEvaluator.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFsiEvaluator.RegisterTransformation \nRegisterTransformation \nFsiEvaluator.EvaluationFailed \nEvaluationFailed"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#RegisterTransformation","title":"FsiEvaluator.RegisterTransformation","content":"FsiEvaluator.RegisterTransformation \nRegisterTransformation \n\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\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluator.html#EvaluationFailed","title":"FsiEvaluator.EvaluationFailed","content":"FsiEvaluator.EvaluationFailed \nEvaluationFailed \n\n This event is fired whenever an evaluation of an expression fails\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html","title":"FsiEvaluatorConfig","content":"FsiEvaluatorConfig \n\n Provides configuration options for the FsiEvaluator\n \nFsiEvaluatorConfig.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFsiEvaluatorConfig.CreateNoOpFsiObject \nCreateNoOpFsiObject"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html#CreateNoOpFsiObject","title":"FsiEvaluatorConfig.CreateNoOpFsiObject","content":"FsiEvaluatorConfig.CreateNoOpFsiObject \nCreateNoOpFsiObject \n\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.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluationresult.html","title":"IFsiEvaluationResult","content":"IFsiEvaluationResult \n\n An interface that represents FSI evaluation result\n (we make this abstract so that evaluators can store other info)\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html","title":"IFsiEvaluator","content":"IFsiEvaluator \n\n Represents an evaluator for F# snippets embedded in code\n \nIFsiEvaluator.Evaluate \nEvaluate \nIFsiEvaluator.Format \nFormat"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html#Evaluate","title":"IFsiEvaluator.Evaluate","content":"IFsiEvaluator.Evaluate \nEvaluate \n\n Called to evaluate a snippet\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html#Format","title":"IFsiEvaluator.Format","content":"IFsiEvaluator.Format \nFormat \n\n Called to format some part of evaluation result generated by FSI\n"},{"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"},{"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"},{"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"},{"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"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#strong","title":"Dsl.strong","content":"Dsl.strong \nstrong \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#p","title":"Dsl.p","content":"Dsl.p \np \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#span","title":"Dsl.span","content":"Dsl.span \nspan \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#(!!)","title":"Dsl.(!!)","content":"Dsl.(!!) \n(!!) \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#link","title":"Dsl.link","content":"Dsl.link \nlink \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#ul","title":"Dsl.ul","content":"Dsl.ul \nul \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#ol","title":"Dsl.ol","content":"Dsl.ol \nol \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#table","title":"Dsl.table","content":"Dsl.table \ntable \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-dsl.html#img","title":"Dsl.img","content":"Dsl.img \nimg \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-htmlformatting.html","title":"HtmlFormatting","content":"HtmlFormatting \n \nHtmlFormatting.formatAsHtml \nformatAsHtml"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-htmlformatting.html#formatAsHtml","title":"HtmlFormatting.formatAsHtml","content":"HtmlFormatting.formatAsHtml \nformatAsHtml \n\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.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html","title":"MarkdownPatterns","content":"MarkdownPatterns \n\n This module provides an easy way of processing Markdown documents.\n It lets you decompose documents into leafs and nodes with nested paragraphs.\n \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|)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#SpanLeaf","title":"MarkdownPatterns.SpanLeaf","content":"MarkdownPatterns.SpanLeaf \nSpanLeaf \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#SpanNode","title":"MarkdownPatterns.SpanNode","content":"MarkdownPatterns.SpanNode \nSpanNode \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#ParagraphSpans","title":"MarkdownPatterns.ParagraphSpans","content":"MarkdownPatterns.ParagraphSpans \nParagraphSpans \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#ParagraphLeaf","title":"MarkdownPatterns.ParagraphLeaf","content":"MarkdownPatterns.ParagraphLeaf \nParagraphLeaf \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns.html#ParagraphNested","title":"MarkdownPatterns.ParagraphNested","content":"MarkdownPatterns.ParagraphNested \nParagraphNested \n"},{"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"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-paragraphleafinfo.html","title":"ParagraphLeafInfo","content":"ParagraphLeafInfo \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-paragraphnestedinfo.html","title":"ParagraphNestedInfo","content":"ParagraphNestedInfo \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-paragraphspansinfo.html","title":"ParagraphSpansInfo","content":"ParagraphSpansInfo \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-spanleafinfo.html","title":"SpanLeafInfo","content":"SpanLeafInfo \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownpatterns-spannodeinfo.html","title":"SpanNodeInfo","content":"SpanNodeInfo \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html","title":"Markdown","content":"Markdown \n\n Static class that provides methods for formatting\n and transforming Markdown documents.\n \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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#Parse","title":"Markdown.Parse","content":"Markdown.Parse \nParse \n\n Parse the specified text into a MarkdownDocument. Line breaks in the\n inline HTML (etc.) will be stored using the specified string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToFsx","title":"Markdown.ToFsx","content":"Markdown.ToFsx \nToFsx \n\n Transform the provided MarkdownDocument into Fsx and return the result as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml","title":"Markdown.ToHtml","content":"Markdown.ToHtml \nToHtml \n\n Transform Markdown document into HTML format.\n The result will be returned as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToHtml","title":"Markdown.ToHtml","content":"Markdown.ToHtml \nToHtml \n\n Transform the provided MarkdownDocument into HTML\n format and return the result as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToLatex","title":"Markdown.ToLatex","content":"Markdown.ToLatex \nToLatex \n\n Transform Markdown text into LaTeX format. The result will be returned as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToLatex","title":"Markdown.ToLatex","content":"Markdown.ToLatex \nToLatex \n\n Transform the provided MarkdownDocument into LaTeX\n format and return the result as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToMd","title":"Markdown.ToMd","content":"Markdown.ToMd \nToMd \n\n Transform the provided MarkdownDocument into Markdown and return the result as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#ToPynb","title":"Markdown.ToPynb","content":"Markdown.ToPynb \nToPynb \n\n Transform the provided MarkdownDocument into Pynb and return the result as a string.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteHtml","title":"Markdown.WriteHtml","content":"Markdown.WriteHtml \nWriteHtml \n\n Transform Markdown text into HTML format. The result\n will be written to the provided TextWriter.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteHtml","title":"Markdown.WriteHtml","content":"Markdown.WriteHtml \nWriteHtml \n\n Transform the provided MarkdownDocument into HTML\n format and write the result to a given writer.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteLatex","title":"Markdown.WriteLatex","content":"Markdown.WriteLatex \nWriteLatex \n\n Transform Markdown document into LaTeX format. The result\n will be written to the provided TextWriter.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdown.html#WriteLatex","title":"Markdown.WriteLatex","content":"Markdown.WriteLatex \nWriteLatex \n\n Transform the provided MarkdownDocument into LaTeX\n format and write the result to a given writer.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html","title":"MarkdownColumnAlignment","content":"MarkdownColumnAlignment \n\n Column in a table can be aligned to left, right, center or using the default alignment\n \nMarkdownColumnAlignment.AlignLeft \nAlignLeft \nMarkdownColumnAlignment.AlignRight \nAlignRight \nMarkdownColumnAlignment.AlignCenter \nAlignCenter \nMarkdownColumnAlignment.AlignDefault \nAlignDefault"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignLeft","title":"MarkdownColumnAlignment.AlignLeft","content":"MarkdownColumnAlignment.AlignLeft \nAlignLeft \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignRight","title":"MarkdownColumnAlignment.AlignRight","content":"MarkdownColumnAlignment.AlignRight \nAlignRight \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignCenter","title":"MarkdownColumnAlignment.AlignCenter","content":"MarkdownColumnAlignment.AlignCenter \nAlignCenter \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowncolumnalignment.html#AlignDefault","title":"MarkdownColumnAlignment.AlignDefault","content":"MarkdownColumnAlignment.AlignDefault \nAlignDefault \n"},{"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.DefinedLinks \nDefinedLinks \nMarkdownDocument.Paragraphs \nParagraphs"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#DefinedLinks","title":"MarkdownDocument.DefinedLinks","content":"MarkdownDocument.DefinedLinks \nDefinedLinks \n\n Returns a dictionary containing explicitly defined links\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowndocument.html#Paragraphs","title":"MarkdownDocument.Paragraphs","content":"MarkdownDocument.Paragraphs \nParagraphs \n\n Returns a list of paragraphs in the document\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedparagraphs.html","title":"MarkdownEmbedParagraphs","content":"MarkdownEmbedParagraphs \n\n Provides an extensibility point for adding custom kinds of paragraphs into a document\n (MarkdownEmbedParagraphs values can be embedded using MarkdownParagraph.EmbedParagraphs)\n \nMarkdownEmbedParagraphs.Render \nRender"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedparagraphs.html#Render","title":"MarkdownEmbedParagraphs.Render","content":"MarkdownEmbedParagraphs.Render \nRender \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedspans.html","title":"MarkdownEmbedSpans","content":"MarkdownEmbedSpans \n\n Provides an extensibility point for adding custom kinds of spans into a document\n (MarkdownEmbedSpans values can be embedded using MarkdownSpan.EmbedSpans)\n \nMarkdownEmbedSpans.Render \nRender"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownembedspans.html#Render","title":"MarkdownEmbedSpans.Render","content":"MarkdownEmbedSpans.Render \nRender \n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownlistkind.html#Ordered","title":"MarkdownListKind.Ordered","content":"MarkdownListKind.Ordered \nOrdered \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownlistkind.html#Unordered","title":"MarkdownListKind.Unordered","content":"MarkdownListKind.Unordered \nUnordered \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html","title":"MarkdownParagraph","content":"MarkdownParagraph \n\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.\n \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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#Heading","title":"MarkdownParagraph.Heading","content":"MarkdownParagraph.Heading \nHeading \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#Paragraph","title":"MarkdownParagraph.Paragraph","content":"MarkdownParagraph.Paragraph \nParagraph \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#CodeBlock","title":"MarkdownParagraph.CodeBlock","content":"MarkdownParagraph.CodeBlock \nCodeBlock \n\n A code block, whether fenced or via indentation\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#InlineHtmlBlock","title":"MarkdownParagraph.InlineHtmlBlock","content":"MarkdownParagraph.InlineHtmlBlock \nInlineHtmlBlock \n\n A HTML block\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#ListBlock","title":"MarkdownParagraph.ListBlock","content":"MarkdownParagraph.ListBlock \nListBlock \n\n A Markdown List block\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#QuotedBlock","title":"MarkdownParagraph.QuotedBlock","content":"MarkdownParagraph.QuotedBlock \nQuotedBlock \n\n A Markdown Quote block\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#Span","title":"MarkdownParagraph.Span","content":"MarkdownParagraph.Span \nSpan \n\n A Markdown Span block\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#LatexBlock","title":"MarkdownParagraph.LatexBlock","content":"MarkdownParagraph.LatexBlock \nLatexBlock \n\n A Markdown Latex block\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#HorizontalRule","title":"MarkdownParagraph.HorizontalRule","content":"MarkdownParagraph.HorizontalRule \nHorizontalRule \n\n A Markdown Horizontal rule\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#TableBlock","title":"MarkdownParagraph.TableBlock","content":"MarkdownParagraph.TableBlock \nTableBlock \n\n A Markdown Table\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#OtherBlock","title":"MarkdownParagraph.OtherBlock","content":"MarkdownParagraph.OtherBlock \nOtherBlock \n\n Represents a block of markdown produced when parsing of code or tables or quoted blocks is suppressed\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#EmbedParagraphs","title":"MarkdownParagraph.EmbedParagraphs","content":"MarkdownParagraph.EmbedParagraphs \nEmbedParagraphs \n\n A special addition for computing paragraphs\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#YamlFrontmatter","title":"MarkdownParagraph.YamlFrontmatter","content":"MarkdownParagraph.YamlFrontmatter \nYamlFrontmatter \n\n A special addition for YAML-style frontmatter\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraph.html#OutputBlock","title":"MarkdownParagraph.OutputBlock","content":"MarkdownParagraph.OutputBlock \nOutputBlock \n\n A special addition for inserted outputs\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html","title":"MarkdownParagraphs","content":"MarkdownParagraphs \n\n A type alias for a list of paragraphs\n \nMarkdownParagraphs.Length \nLength \nMarkdownParagraphs.IsEmpty \nIsEmpty \nMarkdownParagraphs.Head \nHead \nMarkdownParagraphs.Tail \nTail \nMarkdownParagraphs.Item \nItem \nMarkdownParagraphs.Empty \nEmpty"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Length","title":"MarkdownParagraphs.Length","content":"MarkdownParagraphs.Length \nLength \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#IsEmpty","title":"MarkdownParagraphs.IsEmpty","content":"MarkdownParagraphs.IsEmpty \nIsEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Head","title":"MarkdownParagraphs.Head","content":"MarkdownParagraphs.Head \nHead \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Tail","title":"MarkdownParagraphs.Tail","content":"MarkdownParagraphs.Tail \nTail \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Item","title":"MarkdownParagraphs.Item","content":"MarkdownParagraphs.Item \nItem \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparagraphs.html#Empty","title":"MarkdownParagraphs.Empty","content":"MarkdownParagraphs.Empty \nEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html","title":"MarkdownParseOptions","content":"MarkdownParseOptions \n\n Controls the parsing of markdown\n \nMarkdownParseOptions.None \nNone \nMarkdownParseOptions.ParseCodeAsOther \nParseCodeAsOther \nMarkdownParseOptions.ParseNonCodeAsOther \nParseNonCodeAsOther \nMarkdownParseOptions.AllowYamlFrontMatter \nAllowYamlFrontMatter"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#None","title":"MarkdownParseOptions.None","content":"MarkdownParseOptions.None \nNone \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#ParseCodeAsOther","title":"MarkdownParseOptions.ParseCodeAsOther","content":"MarkdownParseOptions.ParseCodeAsOther \nParseCodeAsOther \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#ParseNonCodeAsOther","title":"MarkdownParseOptions.ParseNonCodeAsOther","content":"MarkdownParseOptions.ParseNonCodeAsOther \nParseNonCodeAsOther \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownparseoptions.html#AllowYamlFrontMatter","title":"MarkdownParseOptions.AllowYamlFrontMatter","content":"MarkdownParseOptions.AllowYamlFrontMatter \nAllowYamlFrontMatter \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html","title":"MarkdownSpan","content":"MarkdownSpan \n\n Represents inline formatting inside a paragraph. This can be literal (with text), various\n formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc.\n \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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#Literal","title":"MarkdownSpan.Literal","content":"MarkdownSpan.Literal \nLiteral \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#InlineCode","title":"MarkdownSpan.InlineCode","content":"MarkdownSpan.InlineCode \nInlineCode \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#Strong","title":"MarkdownSpan.Strong","content":"MarkdownSpan.Strong \nStrong \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#Emphasis","title":"MarkdownSpan.Emphasis","content":"MarkdownSpan.Emphasis \nEmphasis \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#AnchorLink","title":"MarkdownSpan.AnchorLink","content":"MarkdownSpan.AnchorLink \nAnchorLink \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#DirectLink","title":"MarkdownSpan.DirectLink","content":"MarkdownSpan.DirectLink \nDirectLink \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#IndirectLink","title":"MarkdownSpan.IndirectLink","content":"MarkdownSpan.IndirectLink \nIndirectLink \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#DirectImage","title":"MarkdownSpan.DirectImage","content":"MarkdownSpan.DirectImage \nDirectImage \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#IndirectImage","title":"MarkdownSpan.IndirectImage","content":"MarkdownSpan.IndirectImage \nIndirectImage \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#HardLineBreak","title":"MarkdownSpan.HardLineBreak","content":"MarkdownSpan.HardLineBreak \nHardLineBreak \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#LatexInlineMath","title":"MarkdownSpan.LatexInlineMath","content":"MarkdownSpan.LatexInlineMath \nLatexInlineMath \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#LatexDisplayMath","title":"MarkdownSpan.LatexDisplayMath","content":"MarkdownSpan.LatexDisplayMath \nLatexDisplayMath \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspan.html#EmbedSpans","title":"MarkdownSpan.EmbedSpans","content":"MarkdownSpan.EmbedSpans \nEmbedSpans \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html","title":"MarkdownSpans","content":"MarkdownSpans \n\n A type alias for a list of MarkdownSpan values\n \nMarkdownSpans.Length \nLength \nMarkdownSpans.IsEmpty \nIsEmpty \nMarkdownSpans.Head \nHead \nMarkdownSpans.Tail \nTail \nMarkdownSpans.Item \nItem \nMarkdownSpans.Empty \nEmpty"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Length","title":"MarkdownSpans.Length","content":"MarkdownSpans.Length \nLength \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#IsEmpty","title":"MarkdownSpans.IsEmpty","content":"MarkdownSpans.IsEmpty \nIsEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Head","title":"MarkdownSpans.Head","content":"MarkdownSpans.Head \nHead \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Tail","title":"MarkdownSpans.Tail","content":"MarkdownSpans.Tail \nTail \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Item","title":"MarkdownSpans.Item","content":"MarkdownSpans.Item \nItem \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownspans.html#Empty","title":"MarkdownSpans.Empty","content":"MarkdownSpans.Empty \nEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html","title":"MarkdownTableRow","content":"MarkdownTableRow \n\n A type alias representing table row as a list of paragraphs\n \nMarkdownTableRow.Length \nLength \nMarkdownTableRow.IsEmpty \nIsEmpty \nMarkdownTableRow.Head \nHead \nMarkdownTableRow.Tail \nTail \nMarkdownTableRow.Item \nItem \nMarkdownTableRow.Empty \nEmpty"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Length","title":"MarkdownTableRow.Length","content":"MarkdownTableRow.Length \nLength \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#IsEmpty","title":"MarkdownTableRow.IsEmpty","content":"MarkdownTableRow.IsEmpty \nIsEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Head","title":"MarkdownTableRow.Head","content":"MarkdownTableRow.Head \nHead \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Tail","title":"MarkdownTableRow.Tail","content":"MarkdownTableRow.Tail \nTail \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Item","title":"MarkdownTableRow.Item","content":"MarkdownTableRow.Item \nItem \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdowntablerow.html#Empty","title":"MarkdownTableRow.Empty","content":"MarkdownTableRow.Empty \nEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrangemodule.html","title":"MarkdownRange","content":"MarkdownRange \n \nMarkdownRange.zero \nzero \nMarkdownRange.mergeRanges \nmergeRanges"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrangemodule.html#zero","title":"MarkdownRange.zero","content":"MarkdownRange.zero \nzero \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrangemodule.html#mergeRanges","title":"MarkdownRange.mergeRanges","content":"MarkdownRange.mergeRanges \nmergeRanges \n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#StartLine","title":"MarkdownRange.StartLine","content":"MarkdownRange.StartLine \nStartLine \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#StartColumn","title":"MarkdownRange.StartColumn","content":"MarkdownRange.StartColumn \nStartColumn \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#EndLine","title":"MarkdownRange.EndLine","content":"MarkdownRange.EndLine \nEndLine \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-markdown-markdownrange.html#EndColumn","title":"MarkdownRange.EndColumn","content":"MarkdownRange.EndColumn \nEndColumn \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html","title":"ParamKeys","content":"ParamKeys \n\n Defines the parameter keys known to FSharp.Formatting processing code\n \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-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-navbar-position\u0060\u0060 \n\u0060\u0060fsdocs-navbar-position\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-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-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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#root","title":"ParamKeys.root","content":"ParamKeys.root \nroot \n\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkeys.html#\u0060\u0060fsdocs-navbar-position\u0060\u0060","title":"ParamKeys.\u0060\u0060fsdocs-navbar-position\u0060\u0060","content":"ParamKeys.\u0060\u0060fsdocs-navbar-position\u0060\u0060 \n\u0060\u0060fsdocs-navbar-position\u0060\u0060 \n\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting\n"},{"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\n A parameter key known to FSharp.Formatting, available in _menu_template.html\n"},{"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\n A parameter key known to FSharp.Formatting, available in _menu_template.html\n"},{"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\n A parameter key known to FSharp.Formatting, available in _menu_template.html\n"},{"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\n A parameter key known to FSharp.Formatting, available in _menu-item_template.html\n"},{"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\n A parameter key known to FSharp.Formatting, available in _menu-item_template.html\n"},{"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\n A parameter key known to FSharp.Formatting, available in _menu-item_template.html\n"},{"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\n A parameter key known to FSharp.Formatting, available when frontmatter is used correctly\n"},{"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\n A parameter key known to FSharp.Formatting, available when frontmatter is used correctly\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html","title":"FrontMatterFile","content":"FrontMatterFile \n\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.\n \nFrontMatterFile.ParseFromLines \nParseFromLines \nFrontMatterFile.FileName \nFileName \nFrontMatterFile.Category \nCategory \nFrontMatterFile.CategoryIndex \nCategoryIndex \nFrontMatterFile.Index \nIndex"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#ParseFromLines","title":"FrontMatterFile.ParseFromLines","content":"FrontMatterFile.ParseFromLines \nParseFromLines \n\n Parses the category, categoryindex and index from the frontmatter lines\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#FileName","title":"FrontMatterFile.FileName","content":"FrontMatterFile.FileName \nFileName \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#Category","title":"FrontMatterFile.Category","content":"FrontMatterFile.Category \nCategory \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#CategoryIndex","title":"FrontMatterFile.CategoryIndex","content":"FrontMatterFile.CategoryIndex \nCategoryIndex \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-frontmatterfile.html#Index","title":"FrontMatterFile.Index","content":"FrontMatterFile.Index \nIndex \n"},{"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"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-paramkey.html#ParamKey","title":"ParamKey.ParamKey","content":"ParamKey.ParamKey \nParamKey \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html","title":"Substitutions","content":"Substitutions \n\n A list of parameters for substituting in templates, indexed by parameter keys\n \nSubstitutions.Length \nLength \nSubstitutions.IsEmpty \nIsEmpty \nSubstitutions.Head \nHead \nSubstitutions.Tail \nTail \nSubstitutions.Item \nItem \nSubstitutions.Empty \nEmpty"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Length","title":"Substitutions.Length","content":"Substitutions.Length \nLength \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#IsEmpty","title":"Substitutions.IsEmpty","content":"Substitutions.IsEmpty \nIsEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Head","title":"Substitutions.Head","content":"Substitutions.Head \nHead \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Tail","title":"Substitutions.Tail","content":"Substitutions.Tail \nTail \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Item","title":"Substitutions.Item","content":"Substitutions.Item \nItem \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/reference/fsharp-formatting-templating-substitutions.html#Empty","title":"Substitutions.Empty","content":"Substitutions.Empty \nEmpty \n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/codeformat.html","title":"Code formatting\n","content":"(**\n---\ncategory: Advanced\ncategoryindex: 3\nindex: 1\n---\n*)\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,{{fsdocs-package-version}}\u0022\n#endif // FSX\n(*** condition: ipynb ***)\n#if IPYNB\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\n(**\n[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.fsx)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.ipynb)\n\nCode formatting\n==============================\n\nThis page demonstrates how to use \u0060FSharp.Formatting.CodeFormat\u0060 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.\n\nFirst, we need to load the assembly and open necessary namespaces:\n*)\n\nopen FSharp.Formatting.CodeFormat\nopen System.Reflection\n\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.\n\nProcessing F# source\n--------------------\n\nThe formatting agent provides a \u0060cref:M:FSharp.Formatting.CodeFormat.CodeFormatAgent.ParseAndCheckSource\u0060 method (together with an asynchronous\nversion for use from F# and also a version that returns a .NET \u0060Task\u0060 for C#).\nTo call the method, we define a simple F# code as a string:\n*)\n\nlet source =\n \u0022\u0022\u0022\n let hello () =\n printfn \u0022Hello world\u0022\n \u0022\u0022\u0022\n\nlet snippets, diagnostics =\n CodeFormatter.ParseAndCheckSource(\u0022C:\\\\snippet.fsx\u0022, source, None, None, ignore)\n\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. \u0060#r\u0060) and to automatically name\nthe module including all code in the file.\n\nYou can also specify additional parameters, such as \u0060*.dll\u0060 references, by passing\na third argument with compiler options (e.g. \u0060\u0022-r:Foo.dll -r:Bar.dll\u0022\u0060).\n\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](http://www.fssnip.net) as documented in the\n[about page](http://www.fssnip.net/pages/About).\n\n\nWorking with returned tokens\n----------------------------\n\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*)\n\n// Get the first snippet and obtain list of lines\nlet (Snippet (title, lines)) = snippets |\u003E 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) -\u003E\n printf \u0022%s\u0022 code\n\n tip\n |\u003E Option.iter (fun spans -\u003E printfn \u0022%A\u0022 spans)\n | TokenSpan.Omitted _\n | TokenSpan.Output _\n | TokenSpan.Error _ -\u003E ()\n\n printfn \u0022\u0022\n\n(**\nThe \u0060TokenSpan.Token\u0060 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:\n\n let hello[Literal \u0022val hello : unit -\u003E unit\u0022; ...] () =\n printfn[Literal \u0022val printfn : TextWriterFormat\u003C\u0027T\u003E -\u003E \u0027T\u0022; ...] \u0022Hello world\u0022\n\nThe \u0060Omitted\u0060 token is generated if you use the special \u0060(*[omit:...]*)\u0060 command.\nThe \u0060Output\u0060 token is generated if you use the \u0060// [fsi:...]\u0060 command to format\noutput returned by F# interactive. The \u0060Error\u0060 command wraps code that should be\nunderlined with a red squiggle if the code contains an error.\n\nGenerating HTML output\n----------------------\n\nFinally, the \u0060CodeFormat\u0060 type also includes a method \u0060cref:M:FSharp.Formatting.CodeFormat.CodeFormat.FormatHtml\u0060 that can be used\nto 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\nlet prefix = \u0022fst\u0022\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 \u0022%s\u0022 snip.Content\n\n// Print HTML code that is generated for ToolTips\nprintfn \u0022%s\u0022 html.ToolTip\n\n(**\nIf the input contains multiple snippets separated using the \u0060//[snippet:...]\u0060 comment, e.g.:\n*)\n\n(**\n\u003Ctable class=\u0022pre\u0022\u003E\u003Ctr\u003E\u003Ctd class=\u0022lines\u0022\u003E\u003Cpre class=\u0022fssnip\u0022\u003E\n\u003Cspan class=\u0022l\u0022\u003E1: \u003C/span\u003E\n\u003Cspan class=\u0022l\u0022\u003E2: \u003C/span\u003E\n\u003Cspan class=\u0022l\u0022\u003E3: \u003C/span\u003E\n\u003Cspan class=\u0022l\u0022\u003E4: \u003C/span\u003E\n\u003Cspan class=\u0022l\u0022\u003E5: \u003C/span\u003E\n\u003Cspan class=\u0022l\u0022\u003E6: \u003C/span\u003E\n\u003Cspan class=\u0022l\u0022\u003E7: \u003C/span\u003E\n\u003C/pre\u003E\n\u003C/td\u003E\n\u003Ctd class=\u0022snippet\u0022\u003E\u003Cpre class=\u0022fssnip\u0022\u003E\u003Cspan class=\u0022c\u0022\u003E// [snippet: First sample]\u003C/span\u003E\n\u003Cspan class=\u0022i\u0022\u003Eprintf\u003C/span\u003E \u003Cspan class=\u0022s\u0022\u003E\u0022The answer is: %A\u0022\u003C/span\u003E \u003Cspan class=\u0022n\u0022\u003E42\u003C/span\u003E\n\u003Cspan class=\u0022c\u0022\u003E// [/snippet]\u003C/span\u003E\n\n\u003Cspan class=\u0022c\u0022\u003E// [snippet: Second sample]\u003C/span\u003E\n\u003Cspan class=\u0022i\u0022\u003Eprintf\u003C/span\u003E \u003Cspan class=\u0022s\u0022\u003E\u0022Hello world!\u0022\u003C/span\u003E\n\u003Cspan class=\u0022c\u0022\u003E// [/snippet]\u003C/span\u003E\n\u003C/pre\u003E\n\u003C/td\u003E\n\u003C/tr\u003E\n\u003C/table\u003E\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*)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/commandline.html","title":"Command line\n","content":"---\ncategory: Documentation\ncategoryindex: 1\nindex: 1\n---\n# Command line\n\nTo use F# Formatting tools via the command line, you can use the \u0060fsdocs\u0060 dotnet tool.\n\n [lang=text]\n dotnet tool install fsdocs-tool\n dotnet fsdocs [command] [options]\n\n## The build command\n\nThis command processes a \u0060docs\u0060 directory and generates API docs for projects in the solution according to the\nrules of [API doc generation](apidocs.html). The input accepted is described in [content](content.html).\n\n [lang=text]\n fsdocs build\n\nThe command line options accepted are:\n\n| Command Line Option | Description |\n|:---------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| \u0060--input\u0060 | Input directory of content (default: \u0060docs\u0060) |\n| \u0060--projects\u0060 | Project files to build API docs for outputs, defaults to all packable projects |\n| \u0060--output\u0060 | Output Directory (default \u0027output\u0027 for \u0027build\u0027 and \u0027tmp/watch\u0027 for \u0027watch\u0027) |\n| \u0060--noapidocs\u0060 | Disable generation of API docs |\n| \u0060--ignoreprojects\u0060 | Disable project cracking |\n| \u0060--eval\u0060 | Evaluate F# fragments in scripts |\n| \u0060--saveimages\u0060 | Save images referenced in docs |\n| \u0060--nolinenumbers\u0060 | Don\u0027t add line numbers, default is to add line number. |\n| \u0060--parameters\u0060 | Additional substitution parameters for templates |\n| \u0060--nonpublic\u0060 | The tool will also generate documentation for non-public members |\n| \u0060--nodefaultcontent\u0060 | Do not copy default content styles, javascript or use default templates |\n| \u0060--clean\u0060 | Clean the output directory |\n| \u0060--help\u0060 | Display this help screen |\n| \u0060--version\u0060 | Display version information |\n| \u0060--properties\u0060 | Provide properties to dotnet msbuild, e.g. --properties Configuration=Release Version=3.4 |\n| \u0060--fscoptions\u0060 | Additional arguments passed down as \u0060otherflags\u0060 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 \u0060--fscoptions \u0022 -r:MyAssembly.dll\u0022\u0060 |\n| \u0060--strict\u0060 | Fail if docs are missing or can\u0027t be generated |\n\nThe following command line options are also accepted but it is instead recommended you use\nsettings in your .fsproj project files:\n\n| Command Line Option | Description |\n|:-----------------------|:-----------------------------------------|\n| \u0060--sourcefolder\u0060 | Source folder at time of component build (\u0060\u003CFsDocsSourceFolder\u003E\u0060) |\n| \u0060--sourcerepo\u0060 | Source repository for github links (\u0060\u003CFsDocsSourceRepository\u003E\u0060) |\n| \u0060--mdcomments\u0060 | Assume comments in F# code are markdown (\u0060\u003CUsesMarkdownComments\u003E\u0060) |\n\nThe command will report on any \u0060.fsproj\u0060 files that it finds, telling you if it decides to skip a particular file and why.\n\nFor example, a project will be skipped if:\n\n* The project name contains \u0022.Tests\u0022 or \u0022test\u0022 (because it looks like a test project)\n\n* The project does not contain\n\u0060\u0060\u0060\n \u003CGenerateDocumentationFile\u003Etrue\u003C/GenerateDocumentationFile\u003E\n\u0060\u0060\u0060\n\n## The watch command\n\nThis command does the same as \u0060fsdocs build\u0060 but in \u0022watch\u0022 mode, waiting for changes. Only the files in the input\ndirectory (e.g. \u0060docs\u0060) are watched. A browser will be launched automatically (unless \u0060--nolaunch\u0060 is specified).\n\nYou will need to ensure that the input directory exists, and contains at least \u0060index.md\u0060, otherwise the browser will\nreport an error (e.g. \u0022Problem loading...\u0022, \u0022Connection was reset\u0022).\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| \u0060--noserver\u0060 | Do not serve content when watching. |\n| \u0060--nolaunch\u0060 | Do not launch a browser window. |\n| \u0060--open\u0060 | URL extension to launch http://localhost:\u003Cport\u003E/%s. |\n| \u0060--port\u0060 | Port to serve content for http://localhost serving. |\n\n\n\n## Searchable docs\n\nWhen using the command-line tool a Lunr search index is automatically generated in \u0060index.json\u0060.\n\nA search box is included in the default template. To add a search box\nto your own \u0060_template.html\u0060, include \u0060fsdocs-search.js\u0060, which is added to the \u0060content\u0060\nby default.\n\n [lang=text]\n ...\n \u003Cdiv id=\u0022header\u0022\u003E\n \u003Cdiv class=\u0022searchbox\u0022\u003E\n \u003Clabel for=\u0022search-by\u0022\u003E\n \u003Ci class=\u0022fas fa-search\u0022\u003E\u003C/i\u003E\n \u003C/label\u003E\n \u003Cinput data-search-input=\u0022\u0022 id=\u0022search-by\u0022 type=\u0022search\u0022 placeholder=\u0022Search...\u0022 /\u003E\n \u003Cspan data-search-clear=\u0022\u0022\u003E\n \u003Ci class=\u0022fas fa-times\u0022\u003E\u003C/i\u003E\n \u003C/span\u003E\n \u003C/div\u003E\n \u003C/div\u003E\n ...\n\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/evaluation.html","title":"Embedding script output\n","content":"(**\n---\ncategory: Documentation\ncategoryindex: 1\nindex: 6\n---\n*)\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,{{fsdocs-package-version}}\u0022\n#endif // FSX\n(*** condition: ipynb ***)\n#if IPYNB\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\n(**\n[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.fsx)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.ipynb)\n\n# Embedding script output\n\n\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](literate.html) and\nit is implemented using the [F# Compiler service](http://fsharp.github.io/FSharp.Compiler.Service/).\n\n## Including Console Output\n\nTo include the Console output use \u0060\u0060include-output\u0060\u0060:\n\n let test = 40 \u002B 2\n\n printf \u0022A result is: %d\u0022 test\n (*** include-output ***)\n\nThe script defines a variable \u0060test\u0060 and then prints it. The console output is included\nin the output.\n\nTo include the a formatted value use \u0060\u0060include-it\u0060\u0060:\n\n [ 0 .. 99 ]\n\n (*** include-it ***)\n\n\nTo include the meta output of F# Interactive processing such as type signatures use \u0060(*** include-fsi-output ***)\u0060:\n\n let test = 40 \u002B 3\n\n (*** include-fsi-output ***)\n\nTo include both console otuput and F# Interactive output blended use \u0060(*** include-fsi-merged-output ***)\u0060.\n\n let test = 40 \u002B 4\n (*** include-fsi-merged-output ***)\n\nYou can use the same commands with a named snippet:\n\n (*** include-it: test ***)\n (*** include-fsi-output: test ***)\n (*** include-output: test ***)\n\nYou can use the \u0060include-value\u0060 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\nYou can use \u0060fsi.AddPrinter\u0060, \u0060fsi.AddPrintTransformer\u0060 and \u0060fsi.AddHtmlPrinter\u0060 to extend the formatting of objects.\n\n## Emitting Raw Text\n\nTo 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\nwhich would emit\n\n\u003Cpre\u003E\nSome raw text.\n\u003C/pre\u003E\n\ndirectly into the document.\n\nF# Formatting as a Library: Specifying the Evaluator and Formatting\n---------------------------------------\n\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](literate.html).\nAssuming you have all the references in place, you can now create an instance of\n\u0060cref:T:FSharp.Formatting.Literate.Evaluation.FsiEvaluator\u0060 that represents a wrapper for F# interactive and pass it to all the\nfunctions that parse script files or process script files:\n\n*)\nopen FSharp.Formatting.Literate\nopen FSharp.Formatting.Literate.Evaluation\nopen FSharp.Formatting.Markdown\n\n// Sample literate content\nlet content =\n \u0022\u0022\u0022\nlet a = 10\n(*** include-value:a ***)\u0022\u0022\u0022\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 \u0060fsiEvaluator\u0060 parameter is specified, the script is evaluated and so you\ncan use additional commands such as \u0060include-value\u0060. 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!)\n\nIf you specify the \u0060fsiEvaluator\u0060 parameter, but don\u0027t want a specific snippet to be evaluated\n(because it might throw an exception, for example), you can use the \u0060(*** do-not-eval ***)\u0060\ncommand.\n\nThe constructor of \u0060cref:T:FSharp.Formatting.Literate.Evaluation.FsiEvaluator\u0060 takes command line parameters for \u0060fsi.exe\u0060 that can\nbe used to specify, for example, defined symbols and other attributes for F# Interactive.\n\nYou can also subscribe to the \u0060EvaluationFailed\u0060 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.\n\nF# Formatting as a Library: Custom formatting functions\n---------------------------\n\nAs mentioned earlier, values are formatted using a simple \u0060\u0022%A\u0022\u0060 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\u0060[1; 2; 3]\u0060 as HTML ordered lists \u0060\u003Col\u003E\u0060.\n\nThis can be done by calling \u0060cref:M:FSharp.Formatting.Literate.Evaluation.FsiEvaluator.RegisterTransformation\u0060 on the \u0060FsiEvaluator\u0060 instance:\n\n*)\n// Create evaluator \u0026 register simple formatter for lists\nlet fsiEvaluator = FsiEvaluator()\n\nfsiEvaluator.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(**\n\nThe function is called with two arguments - \u0060o\u0060 is the value to be formatted and \u0060ty\u0060\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 \u0060obj\u0060 (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 \u0060InlineHtmlBlock\u0060.\n\nTo use the new \u0060FsiEvaluator\u0060, we can use the same style as earlier. This time, we format\na simple list containing strings:\n*)\nlet listy =\n \u0022\u0022\u0022\n### Formatting demo\nlet test = [\u0022one\u0022;\u0022two\u0022;\u0022three\u0022]\n(*** include-value:test ***)\u0022\u0022\u0022\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 \u0060test\u0060,\nfollowed by a nicely formatted ordered list:\n\n\u003Cblockquote\u003E\n\u003Ch3\u003EFormatting demo\u003C/h3\u003E\n\u003Ctable class=\u0022pre\u0022\u003E\u003Ctr\u003E\u003Ctd class=\u0022lines\u0022\u003E\u003Cpre class=\u0022fssnip\u0022\u003E\n\u003Cspan class=\u0022l\u0022\u003E1: \u003C/span\u003E\n\u003C/pre\u003E\n\u003C/td\u003E\n\u003Ctd class=\u0022snippet\u0022\u003E\u003Cpre class=\u0022fssnip\u0022\u003E\n\u003Cspan class=\u0022k\u0022\u003Elet\u003C/span\u003E \u003Cspanclass=\u0022i\u0022\u003Etest\u003C/span\u003E \u003Cspan class=\u0022o\u0022\u003E=\u003C/span\u003E [\u003Cspan class=\u0022s\u0022\u003E\u0026quot;\u003C/span\u003E\u003Cspan class=\u0022s\u0022\u003Eone\u003C/span\u003E\u003Cspan class=\u0022s\u0022\u003E\u0026quot;\u003C/span\u003E;\u003Cspan class=\u0022s\u0022\u003E\u0026quot;\u003C/span\u003E\u003Cspan class=\u0022s\u0022\u003Etwo\u003C/span\u003E\u003Cspan class=\u0022s\u0022\u003E\u0026quot;\u003C/span\u003E;\u003Cspan class=\u0022s\u0022\u003E\u0026quot;\u003C/span\u003E\u003Cspan class=\u0022s\u0022\u003Ethree\u003C/span\u003E\u003Cspan class=\u0022s\u0022\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\n*)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/markdown.html","title":"Markdown parser\n","content":"(**\n---\ncategory: Advanced\ncategoryindex: 3\nindex: 2\n---\n*)\n(*** condition: prepare ***)\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(*** condition: fsx ***)\n#if FSX\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // FSX\n(*** condition: ipynb ***)\n#if IPYNB\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\n\n(**\n[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.fsx)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.ipynb)\n\nMarkdown parser\n==============================\n\nThis page demonstrates how to use \u0060FSharp.Formatting.Markdown\u0060 to parse a Markdown\ndocument, process the obtained document representation and\nhow to turn the code into a nicely formatted HTML.\n\nFirst, we need to load the assembly and open necessary namespaces:\n*)\n\nopen FSharp.Formatting.Markdown\nopen FSharp.Formatting.Common\n\n\n(**\nParsing documents\n-----------------\n\nThe F# Markdown parser recognizes the standard [Markdown syntax](http://daringfireball.net/projects/markdown/)\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 \u0060cref:M:FSharp.Formatting.Markdown.Markdown.Parse\u0060 method:\n*)\n\nlet document =\n \u0022\u0022\u0022\n# F# Hello world\nHello world in [F#](http://fsharp.net) looks like this:\n\n printfn \u0022Hello world!\u0022\n\nFor more see [fsharp.org][fsorg].\n\n [fsorg]: http://fsharp.org \u0022The F# organization.\u0022 \u0022\u0022\u0022\n\nlet parsed = Markdown.Parse(document)\n\n(**\nThe sample document consists of a first-level heading (written using\none 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\nblock as demonstrated on the last line (and they can then be easily used repeatedly\nfrom multiple places in the document).\n\nWorking with parsed documents\n-----------------------------\n\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 \u0060cref:P:FSharp.Formatting.Markdown.MarkdownDocument.DefinedLinks\u0060 property\nreturns all indirect link definitions:\n*)\n\nparsed.DefinedLinks\n// [fsi:val it : IDictionary\u003Cstring,(string * string option)\u003E =]\n// [fsi: dict [(\u0022fsorg\u0022, (\u0022http://fsharp.org\u0022, Some \u0022The F# organization.\u0022))]]\n\n(**\nThe document content can be accessed using the \u0060cref:P:FSharp.Formatting.Markdown.MarkdownDocument.Paragraphs\u0060 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*)\n\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) ]) -\u003E\n // Recognize heading that has a simple content\n // containing just a literal (no other formatting)\n printfn \u0022%s\u0022 text\n | _ -\u003E ()\n\n(**\nYou can find more detailed information about the document structure and how to process it\nin the book [F# Deep Dives](http://manning.com/petricek2/).\n\nProcessing the document recursively\n-----------------------------------\n\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.).\n\nTo avoid pattern matching on every single kind of span and every single kind of\nparagraph, we can use active patterns from the \u0060cref:T:FSharp.Formatting.Markdown.MarkdownPatterns\u0060 module. These can be use\nto recognize any paragraph or span that can contain child elements:\n\n*)\n\n/// Returns all links in a specified span node\nlet 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\nlet 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\nSeq.collect collectParLinks parsed.Paragraphs\n// [fsi:val it : seq\u003Cstring\u003E =]\n// [fsi: seq [\u0022http://fsharp.net\u0022; \u0022http://fsharp.org\u0022]]\n\n(**\nThe \u0060collectSpanLinks\u0060 function works on individual span elements that contain inline\nformatting (emphasis, strong) and also links. The \u0060DirectLink\u0060 node from \u0060cref:T:FSharp.Formatting.Markdown.MarkdownSpan\u0060 represents an inline\nlink like the one pointing to \u003Chttp://fsharp.net\u003E while \u0060IndirectLink\u0060 represents a\nlink that uses one of the link definitions. The function simply returns the URL associated\nwith the link.\n\nSome span nodes (like emphasis) can contain other formatting, so we need to recursively\nprocess children. This is done by matching against \u0060MarkdownPatterns.SpanNodes\u0060 which is an active\npattern that recognizes any node with children. The library also provides a _function_\nnamed \u0060MarkdownPatterns.SpanNode\u0060 that can be used to reconstruct the same node (when you want\nto transform document). This is similar to how the \u0060ExprShape\u0060 module for working with\nF# quotations works.\n\nThe function \u0060collectParLinks\u0060 processes paragraphs - a paragraph cannot directly be a\nlink so we just need to process all spans. This time, there are three options.\n\u0060ParagraphLeaf\u0060 represents a case where the paragraph does not contain any spans\n(a code block or, for example, a \u0060\u003Chr\u003E\u0060 line); the \u0060ParagraphNested\u0060 case is used for paragraphs\nthat contain other paragraphs (quotation) and \u0060ParagraphSpans\u0060 is used for all other\nparagraphs that contain normal text - here we call \u0060collectSpanLinks\u0060 on all nested spans.\n\nGenerating HTML output\n----------------------\n\nFinally, the \u0060cref:T:FSharp.Formatting.Markdown.Markdown\u0060 type also includes a method \u0060cref:M:FSharp.Formatting.Markdown.Markdown.ToHtml\u0060 that can be used\nto generate an HTML document from the Markdown input. The following example shows how to call it:\n*)\nlet html = Markdown.ToHtml(parsed)\n\n(**\nThere are also methods to generate \u0060.fsx\u0060, \u0060.ipynb\u0060, \u0060.md\u0060 and \u0060.tex\u0060.\n*)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/literate.html","title":"Literate Scripts\n","content":"(**\n---\ncategory: Documentation\ncategoryindex: 1\nindex: 3\n---\n*)\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,{{fsdocs-package-version}}\u0022\n#endif // FSX\n(*** condition: ipynb ***)\n#if IPYNB\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\n\n(**\n[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.fsx)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.ipynb)\n\nLiterate Scripts\n================\n\nThe following example shows most of the features that can be used in a literate\nF# script file with \u0060.fsx\u0060 extension. Most of the features should be quite self-explanatory:\n\n (**\n # First-level heading\n Some more documentation using \u0060Markdown\u0060.\n *)\n\n let helloWorld() = printfn \u0022Hello world!\u0022\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\nThe F# script files is processed as follows:\n\n- A multi-line comment starting with \u0060(**\u0060 and ending with \u0060*)\u0060 is\n turned into text and is processed using the F# Markdown processor\n (which supports standard Markdown commands).\n\n- A single-line comment starting with \u0060(***\u0060 and ending with \u0060***)\u0060\n is treated as a special command. The command can consist of\n \u0060key\u0060, \u0060key: value\u0060 or \u0060key=value\u0060 pairs.\n\n| Literate Command | Description |\n|:-----------------------|:----------------------------|\n| \u0060(** ... *)\u0060 | Markdown |\n| \u0060(*** condition: prepare ***)\u0060 | Utilise a code snippet when analyzing for tooltips or executing for outputs |\n| \u0060(*** condition: ipynb ***)\u0060 | Include a code snippet when making a .ipynb notebook |\n| \u0060(*** condition: tex ***)\u0060 | Include a code snippet when making a .tex output |\n| \u0060(*** condition: html ***)\u0060 | Include a code snippet when making HTML output |\n| \u0060(*** hide ***)\u0060 | Hide the subsequent snippet |\n| \u0060(*** raw ***)\u0060 | The subsequent code is treated as raw text |\n\n### Naming and including snippets\n\nThe command \u0060define\u0060 defines a named snippet (such as \u0060final-sample\u0060) 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| Literate Command | Description |\n|:-----------------------|:----------------------------|\n| \u0060(*** define: snippet-name ***)\u0060 | Define a named snippet |\n| \u0060(*** include: snippet-name ***)\u0060 | Include the code of the named snippet |\n\n### Naming and including outputs\n\n| Literate Command | Description |\n|:-----------------------|:----------------------------|\n| \u0060(*** define-output: output-name ***)\u0060 | Define a name for the outputs of the preceding snippet |\n| \u0060(*** include-output ***)\u0060 | The console output of the preceding snippet |\n| \u0060(*** include-output: output-name ***)\u0060 | The console output of the snippet (named with define-output) |\n| \u0060(*** include-fsi-output ***)\u0060 | The F# Interactive output of the preceding snippet |\n| \u0060(*** include-fsi-output: output-name ***)\u0060 | The F# Interactive output of the snippet (named with define-output) |\n| \u0060(*** include-fsi-merged-output ***)\u0060 | The merge of console output and F# Interactive output of the preceding snippet |\n| \u0060(*** include-fsi-merged-output: output-name ***)\u0060 | The merge of console output and F# Interactive output of the snippet (named with define-output) |\n| \u0060(*** include-it ***)\u0060 | The formatted result of the preceding snippet |\n| \u0060(*** include-it: output-name ***) \u0060 | The formatted result of the snippet (named with define-output) |\n| \u0060(*** include-it-raw ***)\u0060 | The unformatted result of the preceding snippet |\n| \u0060(*** include-it-raw: output-name ***)\u0060 | The unformatted result of the snippet (named with define-output) |\n| \u0060(*** include-value: value-name ***)\u0060 | The formatted value, an F# identifier name |\n\n#### Hiding code snippets\n\nThe command \u0060hide\u0060 specifies that the following F# code block (until the next comment or command) should be\nomitted from the output.\n\n#### Evaluating and formatting results\n\nThe commands to evaluate and format results are explained in [evaluation](evaluation.html).\nYou must build your documentation with evaluation turned on using \u0060--eval\u0060.\n\n#### Substitutions\n\nSubstitutions are applied to content, see [content](content.html).\n\n### Literate Markdown Documents\n\nFor files with \u0060.md\u0060 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\n [lang=text]\n # First-level heading\n\n [hide]\n let print s = printfn \u0022%s\u0022 s\n\n Some more documentation using \u0060Markdown\u0060.\n\n [module=Hello]\n let helloWorld() = print \u0022Hello world!\u0022\n\n ## Second-level heading\n With 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 \u0060[...]\u0060:\n\n - The \u0060hide\u0060 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 - The \u0060module=Foo\u0060 command can be used to specify F# \u0060module\u0060 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 - The \u0060lang=foo\u0060 command specifies the language of the named snippet. If the language\n is other than \u0060fsharp\u0060, the snippet is copied to the output as \u0060\u003Cpre\u003E\u0060 HTML\n tag without any processing.\n\n*)\n\n(**\n### LaTeX in Literate Scripts and Markdown Documents\n\nLiterate Scripts may contain LaTeX sections in Markdown using these forms:\n\n1. Single line latex starting with \u0060$$\u0060.\n\n2. A block delimited by \u0060\\begin{equation}...\\end{equation}\u0060 or \u0060\\begin{align}...\\end{align}\u0060.\n\n3. An indented paragraph starting with \u0060$$$\u0060. This is F#-literate-specific and corresponds to\n \u0060\\begin{equation}...\\end{equation}\u0060.\n\nFor 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\nBecomes\n\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\nThe LaTeX will also be used in HTML and iPython notebook outputs.\n\n### Making literate scripts work for different outputs\n\nLiterate scripts and markdown can by turned into LaTex, Python Notebooks and F# scripts.\n\nA header may be needed to get the code to load, a typical example is this:\n\n\u0060\u0060\u0060text\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,{{fsdocs-package-version}}\u0022\n#endif // FSX\n (*** condition: ipynb ***)\n#if IPYNB\n #r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\u0060\u0060\u0060\n\n### Processing literate files programatically\n\nTo process file Use the two static methods to turn single documents into HTML\nas follows using functionality from the \u0060cref:T:FSharp.Formatting.Literate.Literate\u0060 type:\n*)\nopen System.IO\nopen FSharp.Formatting.Literate\n\nlet source = __SOURCE_DIRECTORY__\nlet template = Path.Combine(source, \u0022template.html\u0022)\n\nlet script = Path.Combine(source, \u0022../docs/script.fsx\u0022)\n\nLiterate.ConvertScriptFile(script, template)\n\nlet doc = Path.Combine(source, \u0022../docs/document.md\u0022)\n\nLiterate.ConvertMarkdownFile(doc, template)\n\n(**\n\nThe following sample also uses optional parameter \u0060parameters\u0060 to specify additional\nkeywords that will be replaced in the template file (this matches the \u0060template-project.html\u0060\nfile which is included as a sample in the package):\n*)\n\n// Load the template \u0026 specify project information\nlet projTemplate = source \u002B \u0022template-project.html\u0022\n\nlet projInfo =\n [ \u0022fsdocs-authors\u0022, \u0022Tomas Petricek\u0022\n \u0022fsdocs-source-link\u0022, \u0022https://github.com/fsprojects/FSharp.Formatting\u0022\n \u0022fsdocs-collection-name\u0022, \u0022F# Formatting\u0022 ]\n\n(**\n\nThe methods used above (\u0060cref:M:FSharp.Formatting.Literate.Literate.ConvertScriptFile\u0060, \u0060cref:M:FSharp.Formatting.Literate.Literate.ConvertMarkdownFile\u0060)\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:\n*)\nlet templateTex = Path.Combine(source, \u0022template.tex\u0022)\n\nlet scriptTex = Path.Combine(source, \u0022../docs/script.fsx\u0022)\n\nLiterate.ConvertScriptFile(scriptTex, templateTex, outputKind = OutputKind.Latex)\n\nlet docTex = Path.Combine(source, \u0022../docs/document.md\u0022)\n\nLiterate.ConvertMarkdownFile(docTex, templateTex, outputKind = OutputKind.Latex)\n\n(**\n\nThe methods used above (\u0060ConvertScriptFile\u0060, \u0060ConvertMarkdownFile\u0060)\ncan also produce iPython Notebook output. This is done\nby setting the named parameter \u0060format\u0060 to \u0060OutputKind.Pynb\u0060:\n*)\n\n// Process script file, Markdown document and a directory\nlet scriptPynb = Path.Combine(source, \u0022../docs/script.fsx\u0022)\n\nLiterate.ConvertScriptFile(scriptPynb, outputKind = OutputKind.Pynb)\n\nlet docPynb = Path.Combine(source, \u0022../docs/document.md\u0022)\n\nLiterate.ConvertMarkdownFile(docPynb, outputKind = OutputKind.Pynb)\n\n(**\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\n*)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/apidocs.html","title":"Generating API Docs","content":"(**\n---\ntitle: Generating API Docs\ncategory: Documentation\ncategoryindex: 1\nindex: 5\n---\n*)\n(*** condition: prepare ***)\n#nowarn \u0022211\u0022\n#I \u0022../src/FSharp.Formatting/bin/Release/netstandard2.1\u0022\n#r \u0022FSharp.Compiler.Service\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,{{fsdocs-package-version}}\u0022\n#endif // FSX\n(*** condition: ipynb ***)\n#if IPYNB\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\n(*** hide ***)\nlet root = \u0022C:\\\\\u0022\n\n(**\n[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.fsx)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.ipynb)\n\nAPI Documentation Generation\n====================================\n\nThe [command-line tool \u0060fsdocs\u0060](commandline.html) can be used to generate documentation\nfor F# libraries with XML comments. The documentation is normally built using \u0060fsdocs build\u0060 and developed using \u0060fsdocs watch\u0060. For\nthe former the output will be placed in \u0060output\\reference\u0060 by default.\n\n## Selected projects\n\n\u0060fsdocs\u0060 automatically selects the projects and \u0022cracks\u0022 the project files for information\n\n* Projects with \u0060GenerateDocumentationFile\u0060 and without \u0060IsTestProject\u0060 are selected.\n* Projects must not use \u0060TargetFrameworks\u0060 (only \u0060TargetFramework\u0060, singular).\n\n\u0060\u0060\u0060text\n \u003CPropertyGroup\u003E\n \u003CGenerateDocumentationFile\u003Etrue\u003C/GenerateDocumentationFile\u003E\n \u003C/PropertyGroup\u003E\n\u0060\u0060\u0060\n\n## Templates\n\nThe HTML is built by instantiating a template. The template used is the first of:\n\n* \u0060docs/reference/_template.html\u0060\n\n* \u0060docs/_template.html\u0060\n\n* The default template\n\nUsually the same template can be used as for [other content](content.html).\n\n## Classic XML Doc Comments\n\nXML Doc Comments may use [the normal F# and C# XML doc standards](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/xmldoc/).\n\nThe tags that form the core of the XML doc specification are:\n\n\u0060\u0060\u0060\n\u003Cc\u003E\t\u003Cpara\u003E\t\u003Csee\u003E*\t\u003Cvalue\u003E\n\u003Ccode\u003E\t\u003Cparam\u003E*\t\u003Cseealso\u003E*\n\u003Cexample\u003E\t\u003Cparamref\u003E\t\u003Csummary\u003E\n\u003Cexception\u003E*\t\u003Cpermission\u003E*\t\u003Ctypeparam\u003E*\n\u003Cinclude\u003E*\t\u003Cremarks\u003E\t\u003Ctypeparamref\u003E\n\u003Clist\u003E\t\u003Cinheritdoc\u003E\t\u003Creturns\u003E\n\u0060\u0060\u0060\n\nIn addition, you may also use the [Recommended XML doc extensions for F# documentation tooling](https://github.com/fsharp/fslang-design/blob/master/tooling/FST-1031-xmldoc-extensions.md).\n\n* \u0060\u003Ca href = \u0022...\u0022\u003E\u0060 links\n\n* Arbitrary paragraph-level HTML such as \u0060\u003Cb\u003E\u0060 for bold in XML doc text\n\n* \u0060\u003Cnamespacedoc\u003E\u0060 giving documentation for the enclosing namespace\n\n* \u0060\u003Cexclude/\u003E\u0060 to exclude from XML docs\n\n* \u0060\u003Ccategory\u003E\u0060 to give a category for an entity or member. An optional \u0060index\u0060 attribute can be specified\n to help sort the list of categories.\n\n* \u0060\\(...\\)\u0060 for inline math and \u0060$$...$$\u0060 and \u0060\\[...\\]\u0060for math environments, see http://docs.mathjax.org.\n Some escaping of characters (e.g. \u0060\u0026lt;\u0060, \u0060\u0026gt;\u0060) may be needed to form valid XML\n\nAn example of an XML documentation comment, assuming the code is in namespace \u0060TheNamespace\u0060:\n*)\n/// \u003Csummary\u003E\n/// A module\n/// \u003C/summary\u003E\n///\n/// \u003Cnamespacedoc\u003E\n/// \u003Csummary\u003EA namespace to remember\u003C/summary\u003E\n///\n/// \u003Cremarks\u003EMore on that\u003C/remarks\u003E\n/// \u003C/namespacedoc\u003E\n///\nmodule SomeModule =\n /// \u003Csummary\u003E\n /// Some actual comment\n /// \u003Cpara\u003EAnother paragraph, see \u003Csee cref=\u0022T:TheNamespace.SomeType\u0022/\u003E. \u003C/para\u003E\n /// \u003C/summary\u003E\n ///\n /// \u003Cparam name=\u0022x\u0022\u003EThe input\u003C/param\u003E\n ///\n /// \u003Creturns\u003EThe output\u003C/returns\u003E\n ///\n /// \u003Cexample\u003E\n /// Try using\n /// \u003Ccode\u003E\n /// open TheNamespace\n /// SomeModule.a\n /// \u003C/code\u003E\n /// \u003C/example\u003E\n ///\n /// \u003Ccategory\u003EFoo\u003C/category\u003E\n let someFunction x = 42 \u002B x\n\n/// \u003Csummary\u003E\n/// A type, see \u003Csee cref=\u0022T:TheNamespace.SomeModule\u0022/\u003E and\n/// \u003Csee cref=\u0022M:TheNamespace.SomeModule.someFunction\u0022/\u003E.\n/// \u003C/summary\u003E\n///\ntype SomeType() =\n member x.P = 1\n\n(**\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:\n*)\n\ntype Class2() =\n member this.Property = \u0022more\u0022\n member this.Method0() = \u0022more\u0022\n member this.Method1(c: string) = \u0022more\u0022\n member this.Method2(c: string, o: obj) = \u0022more\u0022\n\n/// \u003Csee cref=\u0022P:TheNamespace.Class2.Property\u0022 /\u003E\n/// and \u003Csee cref=\u0022M:TheNamespace.Class2.OtherMethod0\u0022 /\u003E\n/// and \u003Csee cref=\u0022M:TheNamespace.Class2.Method1(System.String)\u0022 /\u003E\n/// and \u003Csee cref=\u0022M:TheNamespace.Class2.Method2(System.String,System.Object)\u0022 /\u003E\nlet referringFunction1 () = \u0022result\u0022\n\n(**\nGeneric types are referred to by .NET compiled name, e.g.\n*)\n\ntype GenericClass2\u003C\u0027T\u003E() =\n member this.Property = \u0022more\u0022\n\n member this.NonGenericMethod(_c: \u0027T) = \u0022more\u0022\n\n member this.GenericMethod(_c: \u0027T, _o: \u0027U) = \u0022more\u0022\n\n/// See \u003Csee cref=\u0022T:TheNamespace.GenericClass2\u00601\u0022 /\u003E\n/// and \u003Csee cref=\u0022P:TheNamespace.GenericClass2\u00601.Property\u0022 /\u003E\n/// and \u003Csee cref=\u0022M:TheNamespace.GenericClass2\u00601.NonGenericMethod(\u00600)\u0022 /\u003E\n/// and \u003Csee cref=\u0022M:TheNamespace.GenericClass2\u00601.GenericMethod\u0060\u00601(\u00600,\u0060\u00600)\u0022 /\u003E\nlet referringFunction2 () = \u0022result\u0022\n\n(**\n### Cross-referencing with \u0026lt;seealso\u0026gt;\n\nUse \u0060\u003Cseealso cref=\u0022...\u0022/\u003E\u0060 within \u0060\u003Csummary\u003E\u0060 to create cross-references.\n\nFor example:\n*)\n\nmodule Forest =\n\n /// \u003Csummary\u003E\n /// Find at most \u003Cc\u003Elimit\u003C/c\u003E foxes in current forest\n ///\n /// See also: \u003Cseealso cref=\u0022M:App.Forest.findSquirrels(System.Int32)\u0022/\u003E\n /// \u003C/summary\u003E\n let findFoxes (limit : int) = []\n\n /// \u003Csummary\u003E\n /// Find at most \u003Cc\u003Elimit\u003C/c\u003E squirrels in current forest\n ///\n /// See also: \u003Cseealso cref=\u0022M:App.Forest.findFoxes(System.Int32)\u0022/\u003E\n /// \u003C/summary\u003E\n let findSquirrels (limit : int) = []\n\n\n(** You can find the correct value for \u0060cref\u0060 in the generated \u0060.xml\u0060 documentation file (this will be generated alongside the assembly\u0027s \u0060.dll\u0060\u0060).\n\nYou can also omit the \u0060cref\u0060\u0027s arguments, and \u0060fsdocs\u0060 will make an attempt to find the first member that matches.\n\nFor example:\n\u0060\u0060\u0060\n /// See also: \u003Cseealso cref=\u0022M:App.Forest.findSquirrels\u0022/\u003E\n\u0060\u0060\u0060\n\nIf the member cannot be found, a link to the containing module/type will be used instead.\n*)\n\n\n(**\n### Classic XMl Doc Comments: Excluding APIs from the docs\n\nIf you want to exclude modules or functions from the API docs you can use the \u0060\u003Cexclude/\u003E\u0060 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 \u0060\u003Csummary\u003E\u0060 (for example, you may wish to hide existing documentation while it\u0027s in progress).\nThe \u0060\u003Cexclude/\u003E\u0060 tag can be the first or last line in these cases.\n\nSome examples:\n*)\n\n/// \u003Cexclude/\u003E\nmodule BottleKids1 =\n let a = 42\n\n// Ordinary comment\n/// \u003Cexclude/\u003E\nmodule BottleKids2 =\n let a = 43\n\n/// \u003Cexclude/\u003E\n/// BottleKids3 provides improvements over BottleKids2\nmodule BottleKids3 =\n let a = 44\n\n/// BottleKids4 implements several new features over BottleKids3\n/// \u003Cexclude/\u003E\nmodule BottleKids4 =\n let a = 45\n\n/// \u003Cexclude/\u003E\n/// \u003Csummary\u003E\n/// BottleKids5 is all you\u0027ll ever need in terms of bottles or kids.\n/// \u003C/summary\u003E\nmodule BottleKids5 =\n let a = 46\n\n(**\n\nNote that the comments for \u0060BottleKids3\u0060 (and \u0060BottleKids4\u0060) will generate a warning. This is because\nthe \u0060\u003Cexclude/\u003E\u0060 tag will be parsed as part of the \u0060summary\u0060 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 \u0060\u003Csummary\u003E\u0060 tags to remove\nthe warning.\n\nThe warning will be of the following format:\n\u0060\u0060\u0060\nWarning: detected \u0022\u003Cexclude/\u003E\u0022 in text of \u0022\u003Csummary\u003E\u0022 for \u0022M:YourLib.BottleKids4\u0022. Please see https://fsprojects.github.io/FSharp.Formatting/apidocs.html#Classic-XML-Doc-Comments\n\u0060\u0060\u0060\nYou will find that \u0060[omit]\u0060 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:\n\n\u0060\u0060\u0060\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\u0060\u0060\u0060\n\n*)\n(**\n\n## Go to Source links\n\n\u0027fsdocs\u0027 normally automatically adds GitHub links to each functions, values and class members for further reference.\n\nThis is normally done automatically based on the following settings:\n\n\u0060\u0060\u0060xml\n \u003CRepositoryUrl\u003Ehttps://github.com/...\u003C/RepositoryUrl\u003E\n \u003CRepositoryBranch\u003E...\u003C/RepositoryBranch\u003E\n \u003CRepositoryType\u003Egit\u003C/RepositoryType\u003E\n\u0060\u0060\u0060\n\nIf your source is not built from the same project where you are building documentation then\nyou may need these settings:\n\n\u0060\u0060\u0060xml\n \u003CFsDocsSourceRepository\u003E...\u003C/FsDocsSourceRepository\u003E -- the URL for the root of the source\n \u003CFsDocsSourceFolder\u003E...\u003C/FsDocsSourceFolder\u003E -- the root soure folder at time of build\n\u0060\u0060\u0060\n\nIt is assumed that \u0060sourceRepo\u0060 and \u0060sourceFolder\u0060 have synchronized contents.\n\n## Markdown Comments\n\nYou can use Markdown instead of XML in \u0060///\u0060 comments. If you do, you should set \u0060\u003CUsesMarkdownComments\u003Etrue\u003C/UsesMarkdownComments\u003E\u0060 in\nyour F# project file.\n\n\u003E Note: Markdown Comments are not supported in all F# IDE tooling.\n\n### Adding cross-type links to modules and types in the same assembly\n\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* Add a [markdown inline link](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#links) were the link\ntitle is the name of the type you want to link.\n\n /// this will generate a link to [Foo.Bar] documentation\n\n* Add a [Markdown inline code](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code) (using\nback-ticks) where the code is the name of the type you want to link.\n\n /// This will also generate a link to \u0060Foo.Bar\u0060 documentation\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*)\n\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\n(**\n### Markdown Comments: Excluding APIs from the docs\n\nIf you want to exclude modules or functions from the API docs you can use the \u0060[omit]\u0060 tag.\nIt needs to be set on a separate triple-slashed line, but it could be either the first or the last:\n\nExample as last line:\n*)\n\n/// Some actual comment\n/// [omit]\nmodule Bar =\n let a = 42\n\n(**\nExample as first line:\n*)\n\n/// [omit]\n/// Some actual comment\nmodule Bar2 =\n let a = 42\n\n(**\n\n\n## Building library documentation programmatically\n\nYou can build library documentation programatically using the functionality\nin the \u0060cref:T:FSharp.Formatting.ApiDocs.ApiDocs\u0060 type. To do this, load the assembly and open necessary namespaces:\n*)\n\n#r \u0022FSharp.Formatting.ApiDocs.dll\u0022\n\nopen FSharp.Formatting.ApiDocs\nopen System.IO\n\n(**\nFor example the \u0060cref:M:FSharp.Formatting.ApiDocs.ApiDocs.GenerateHtml\u0060 method:\n*)\n\nlet file = Path.Combine(root, \u0022bin/YourLibrary.dll\u0022)\n\nlet input = ApiDocInput.FromFile(file)\n\nApiDocs.GenerateHtml(\n [ input ],\n output = Path.Combine(root, \u0022output\u0022),\n collectionName = \u0022YourLibrary\u0022,\n template = Path.Combine(root, \u0022templates\u0022, \u0022template.html\u0022),\n substitutions = []\n)\n\n(**\n### Adding extra dependencies\n\nWhen building a library programmatically, you might require a reference to an additional assembly.\nYou can pass this using the \u0060otherFlags\u0060 argument.\n*)\n\nlet projectAssembly = Path.Combine(root, \u0022bin/X.dll\u0022)\n\nlet projectInput = ApiDocInput.FromFile(projectAssembly)\n\nApiDocs.GenerateHtml(\n [ projectInput ],\n output = Path.Combine(root, \u0022output\u0022),\n collectionName = \u0022Project X\u0022,\n template = Path.Combine(root, \u0022templates\u0022, \u0022template.html\u0022),\n substitutions = [],\n otherFlags = [ \u0022-r:/root/ProjectY/bin/Debug/net6.0/Y.dll\u0022 ]\n)\n\n(**\nor use \u0060libDirs\u0060 to include all assemblies from an entire folder.\nTip: A combination of \u0060\u003CCopyLocalLockFileAssemblies\u003Etrue\u003C/CopyLocalLockFileAssemblies\u003E\u0060 in the fsproj file and setting \u0060libDirs\u0060 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.\n*)\n\nApiDocs.GenerateHtml(\n [ projectInput ],\n output = Path.Combine(root, \u0022output\u0022),\n collectionName = \u0022Project X\u0022,\n template = Path.Combine(root, \u0022templates\u0022, \u0022template.html\u0022),\n substitutions = [],\n libDirs = [ \u0022ProjectX/bin/Debug/netstandard2.0\u0022 ]\n)\n\n(**\n## Rebasing Links\n\nThe \u0060root\u0060 parameter is used for the base of page and image links in the generated documentation. By default it is derived from the project\u0027s \u0060\u003CPackageProjectUrl\u003E\u0060 property.\n\nIn some instances, you may wish to override the value for \u0060root\u0060 (perhaps for local testing). To do this, you can use the command-line argument \u0060--parameters root \u003Cbase\u003E\u0060.\n\nFor example:\n\n [lang=text]\n dotnet fsdocs build --output public/docs --parameters root ../\n\n*)"},{"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\n\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.\n\nTo use the tool, install and use the [fsdocs](commandline.html) tool in a typical F# project with\nF# project files plus markdown and script content in the \u0060docs\u0060 directory:\n\n dotnet tool install fsdocs-tool\n dotnet fsdocs build \n dotnet fsdocs watch\n\nTo use the tool, explore the following topics:\n\n- [Authoring Content](content.html) - explains the content expected in the \u0060docs\u0060 directory for the \u0060fsdocs\u0060 tool.\n\n- [Using the Command line tool](commandline.html) - explains how to use the \u0060fsdocs\u0060 tool.\n\n- [Generating API documentation](apidocs.html) - how to generate HTML documentation\n from \u0022XML comments\u0022 in your .NET libraries. The tool handles comments written in\n Markdown too.\n\n- [Styling](styling.html) - explains some options for styling the output of \u0060fsdocs\u0060.\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- [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## Using FSharp.Formatting as a library\n\nF# 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- [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## More information\n\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](https://github.com/fsprojects/FSharp.Formatting/tree/master/docs).\n\nThe 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.\nSee the [License file](https://github.com/fsprojects/FSharp.Formatting/blob/master/LICENSE.md) in the GitHub repository.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/styling.html","title":"Customization and Styling\n","content":"---\ncategory: Documentation\ncategoryindex: 1\nindex: 7\n---\n# Customization and Styling \n\nWhen using \u0060fsdocs\u0060, there are six levels of extra content development and styling.\n\n1. Don\u0027t do any styling or documentation customization and simply write content. This is by far the simplest option to maintain.\n\n2. Add content such as an \u0060docs/index.md\u0060 to customize the front-page content for your generated docs.\n You can also add content such as \u0060docs/reference/fslib.md\u0060 to give a bespoke landing page\n for one of your namespaces, e.g. here assumed to be \u0060namespace FsLib\u0060. This will override any\n generated content.\n\n3. Customize via Styling Parameters\n\n4. Customize via CSS\n\n5. Customize via a new template\n\n6. Customize by generating your own site using your own code\n\nBy default \u0060fsdocs\u0060 does no styling customization and uses the following defaults. These are the settings used to build this site.\n\n* Uses the default template in [docs/_template.html](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/_template.html)\n\n* Uses the default styles in [docs/content/fsdocs-default.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).\n\n* Uses no custom styles in [docs/content/fsdocs-custom.css](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/content/fsdocs-default.css).\n\n* Uses 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.\n\n## Customizing via Styling Parameters\n\nThe following [content parameters](content.html) are particularly related to visual styling:\n\n| Substitution name | Value (if not overriden by --parameters) | \n|:------------------------------------|:--------------------------------------------------------------|\n| \u0060fsdocs-authors\u0060 | \u0060\u003CAuthors\u003E\u0060 | \n| \u0060fsdocs-collection-name-link\u0060 | \u0060\u003CFsDocsCollectionNameLink\u003E\u0060 | \n| \u0060fsdocs-license-link\u0060 | \u0060\u003CFsDocsLicenseLink\u003E\u0060 | \n| \u0060fsdocs-logo-src\u0060 | \u0060\u003CFsDocsLogoSource\u003E\u0060 | \n| \u0060fsdocs-logo-link\u0060 | \u0060\u003CFsDocsLogoLink\u003E\u0060 | \n| \u0060fsdocs-navbar-position\u0060 | \u0060\u003CFsDocsNavbarPosition\u003E\u0060 (\u0060fixed-left\u0060 or \u0060fixed-right\u0060) | \n| \u0060fsdocs-release-notes-link\u0060 | \u0060\u003CFsDocsReleaseNotesLink\u003E\u0060 else \u0060\u003CPackageProjectUrl\u003E/blob/master/RELEASE_NOTES.md\u0060 | \n| \u0060fsdocs-repository-link\u0060 | \u0060\u003CRepositoryUrl\u003E\u0060 | \n| \u0060fsdocs-theme\u0060 | \u0060\u003CFsDocsTheme\u003E\u0060, must currently be \u0060default\u0060 | \n\nThese basic entry-level styling parameters can be set in the project file or \u0060Directory.Build.props\u0060.\nFor example:\n\n\u0060\u0060\u0060xml\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 \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 \u003CFsDocsNavbarPosition\u003Efixed-left\u003C/FsDocsNavbarPosition\u003E\n \u003CFsDocsWarnOnMissingDocs\u003Etrue\u003C/FsDocsWarnOnMissingDocs\u003E\n \u003CFsDocsTheme\u003Edefault\u003C/FsDocsTheme\u003E\n\u0060\u0060\u0060\n\nAs an example, here is [a page with \u0060fsdocs-navbar-position\u0060 set to \u0060fixed-right\u0060](templates/leftside/styling.html).\n\n## Customizing via CSS\n\nYou can start styling by creating a file \u0060docs/content/fsdocs-custom.css\u0060 and adding entries to it. It is loaded by\nthe standard template. The CSS classes of generated content are:\n\n| CSS class | Corresponding Content| \n|:------------------------------------|:--------------------------------------------------------------|\n| \u0060.fsdocs-tip\u0060 | generated tooltips | \n| \u0060.fsdocs-xmldoc\u0060 | generated xmldoc sections |\n| \u0060.fsdocs-member-list\u0060 | generated member lists (tables) |\n| \u0060.fsdocs-member-usage\u0060 | usage in generated member lists |\n| \u0060.fsdocs-member-tooltip\u0060 | tooltips in generated member lists |\n| \u0060.fsdocs-member-xmldoc\u0060 | documentation in generated member lists |\n| \u0060.fsdocs-entity-list\u0060 | generated entity lists |\n| \u0060.fsdocs-entity-name\u0060 | generated entity lists |\n| \u0060.fsdocs-entity-xmldoc\u0060 | documentation in generated entity lists |\n| \u0060.fsdocs-exception-list\u0060 | generated exception lists |\n| \u0060.fsdocs-summary\u0060 | the \u0027summary\u0027 section of an XML doc |\n| \u0060.fsdocs-remarks\u0060 | the \u0027remarks\u0027 section of an XML doc |\n| \u0060.fsdocs-params\u0060 | the \u0027parameters\u0027 section of an XML doc |\n| \u0060.fsdocs-param\u0060 | a \u0027parameter\u0027 section of an XML doc |\n| \u0060.fsdocs-param-name\u0060 | a \u0027parameter\u0027 name of an XML doc |\n| \u0060.fsdocs-returns\u0060 | the \u0027returns\u0027 section of an XML doc |\n| \u0060.fsdocs-example\u0060 | the \u0027example\u0027 section of an XML doc |\n| \u0060.fsdocs-note\u0060 | the \u0027notes\u0027 section of an XML doc |\n| \u0060.fsdocs-para\u0060 | a paragraph of an XML doc |\n\nSome generated elements are given specific HTML ids:\n\n| HTML Element Id | Content| \n|:------------------------------------|:--------------------------------------------------------------|\n| \u0060#fsdocs-content\u0060 | The generated content | \n| \u0060#fsdocs-searchbox \u0060 | The search box |\n| \u0060#fsdocs-logo \u0060 | The logo |\n| \u0060#fsdocs-nav \u0060 | The navigation-bar |\n\nIf you write a new theme by CSS styling please contribute it back to FSharp.Formatting.\n\n## Customizing via a new template\n\nYou can do advanced styling by creating a new template. Add a file \u0060docs/_template.html\u0060, likely starting\nwith the existing default template.\n\n\u003E NOTE: To enable hot reload during development with \u0060fsdocs watch\u0060 in a custom \u0060_template.html\u0060 file,\n\u003E make sure to add the single line \u0060{{fsdocs-watch-script}}\u0060 to your \u0060\u003Chead\u003E\u0060 tag.\n\n\u003E NOTE: There is no guarantee that your template will continue to work with future versions of F# Formatting.\n\u003E If you do develop a good template please consider contributing it back to F# Formatting.\n\n## Customizing menu items by template\n\nYou can add advanced styling to the sidebar generated menu items by creating a new template for it.\n\u0060fsdoc\u0060 will look for menu templates in the \u0060--input\u0060 folder which defaults to the docs folder.\n\nTo customize the generated menu-item headers, use file \u0060_menu_template.html\u0060 with starting template:\n\n\u0060\u0060\u0060html\n\u003Cli class=\u0022nav-header\u0022\u003E\n {{fsdocs-menu-header-content}}\n\u003C/li\u003E\n{{fsdocs-menu-items}}\n\u0060\u0060\u0060\n\nSimilarly, to customize the individual menu item list, use file \u0060_menu-item_template.html\u0060 with starting template:\n\n\u0060\u0060\u0060html\n\u003Cli class=\u0022nav-item\u0022\u003E\u003Ca href=\u0022{{fsdocs-menu-item-link}}\u0022 class=\u0022nav-link\u0022\u003E{{fsdocs-menu-item-content}}\u003C/a\u003E\u003C/li\u003E\n\u0060\u0060\u0060\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 \u0060{{fsdocs-menu-header-id}}\u0060 and \u0060{{fsdocs-menu-item-id}}\u0060, respectively.\n\n## Customizing by generating your own site using your own code\n\nThe \u0060FSharp.Formatting.ApiDocs\u0060 namespace includes a \u0060GenerateModel\u0060 that captures\nthe results of documentation preparation in \u0060ApiDocsModel\u0060 and allows you to \ngenerate 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 generation will continue to work\n\u003E with future versions of F# Formatting.\n\n\u003E NOTE: The \u0060ApiDocsModel\u0060 currently includes some generated HTML with some specific style tags.\n\u003E In the long term these may be removed from the design of that component.\n\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/content.html","title":"Creating Content\n","content":"(**\n---\ncategory: Documentation\ncategoryindex: 1\nindex: 3\n---\n*)\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,{{fsdocs-package-version}}\u0022\n#endif // FSX\n(*** condition: ipynb ***)\n#if IPYNB\n#r \u0022nuget: FSharp.Formatting,{{fsdocs-package-version}}\u0022\n#endif // IPYNB\n\n\n(**\n[](https://mybinder.org/v2/gh/fsprojects/fsharp.formatting/gh-pages?filepath={{fsdocs-source-basename}}.ipynb)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.fsx)\u0026emsp;\n[]({{root}}/{{fsdocs-source-basename}}.ipynb)\n\nCreating Content\n===================================\n\nThe [\u0022fsdocs\u0022 tool](commandline.html) allows documentation for a site to be built\nfrom content in a \u0060docs\u0060 directory. The expected structure for a \u0060docs\u0060 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\nProcessing is by these two commands:\n\n dotnet fsdocs build\n dotnet fsdocs watch\n\nThe output goes in \u0060output/\u0060 by default. Processing is recursive, making this a form of static site generation.\n\n## Literate Scripts and Markdown Content\n\nThe input directory may contain [literate scripts](literate.html) and markdown content.\n\n## Other Content\n\nContent that is not \u0060*.fsx\u0060 or \u0060*.md\u0060 is copied across.\n\n## Default Styling Content\n\nBy default additional content such as \u0060fsdocs-search.js\u0060, \u0060fsdocs-tips.js\u0060 and \u0060fsdocs-styles.css\u0060 are included in the\nthe \u0060content\u0060 directory of the output. This can be suppressed with \u0060--nodefaultcontent\u0060 or by having your own\ncopy of this content in your \u0060content\u0060 directory.\n\n## Ignored Content\n\nAny file or directory beginning with \u0060.\u0060 is ignored.\n\n## Front matter\n\nEach content file can have optional frontmatter. This determines the navigation bar title, categorization and ordering.\n\nFor markdown, the format is:\n\u0060\u0060\u0060\n---\ntitle: Some Title\ncategory: Some Category\ncategoryindex: 2\nindex: 3\n---\n\u0060\u0060\u0060\nFor 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 ---\n *)\n\nAll entries are optional.\nThe \u0060categoryindex\u0060 determines the ordering of categories.\nThe \u0060index\u0060 determines the ordering of within each category.\nThe \u0060title\u0060 is used in the navigation bar instead of any title inferred from the document.\n\n## Link Translation for Inputs\n\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\n [Some Text](some-file.md)\n\nbecomes\n\n [Some Text](some-file.html)\n\nif \u0060some-file.md\u0060 is one of the inputs.\n\n## Multi-language Content\n\nVersions of content in other languages should go in two-letter coded sub-directories, e.g.\n\n docs/ja/...\n docs/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).\n\n## Templates and Substitutions\n\nTemplates are used for HTML (\u0060_template.html\u0060), LaTeX (\u0060_template.tex\u0060), Notebooks (\u0060_template.ipynb)\u0060\nand F# script outputs (\u0060_template.fsx\u0060).\n\nThe following substitutions determine the primary (non-styling) content of your site.\nFor example \u0060{{fsdocs-content}}\u0060 is replaced with the generated content in each file.\n\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 \u0060...\u0060 \u0060\u0060, Markdown LaTeX and\ngenerated outputs.\n\nSee [Styling](styling.html) for information about template parameters and styling beyond the default template.\n\n| Substitution name | Generated content |\n|:------------------------------|:--------------------------------------------------------------|\n| \u0060root\u0060 | \u0060\u003CPackageProjectUrl\u003E\u0060 else \u0060/\u0060 followed by \u0060fsdocs-collection-name\u0060 |\n| \u0060fsdocs-collection-name\u0060 | Name of .sln, single .fsproj or containing directory |\n| \u0060fsdocs-content\u0060 | Main page content |\n| \u0060fsdocs-list-of-namespaces\u0060 | HTML \u0060\u003Cli\u003E\u0060 list of namespaces with links |\n| \u0060fsdocs-list-of-documents\u0060 | HTML \u0060\u003Cli\u003E\u0060 list of documents with titles and links |\n| \u0060fsdocs-page-title\u0060 | First h1 heading in literate file. Generated for API docs |\n| \u0060fsdocs-source\u0060 | Original literate script or markdown source |\n| \u0060fsdocs-source-filename\u0060 | Name of original input source, relative to the \u0060docs\u0060 root |\n| \u0060fsdocs-source-basename\u0060 | Name of original input source, excluding its extensions, relative to the \u0060docs\u0060 root |\n| \u0060fsdocs-tooltips\u0060 | Generated hidden div elements for tooltips |\n| \u0060fsdocs-watch-script\u0060 | The websocket script used in watch mode to trigger hot reload |\n| \u0060fsdocs-previous-page-link\u0060 | A relative link to the previous page based on the frontmatter index data |\n| \u0060fsdocs-next-page-link\u0060 | A relative link to the next page based on the frontmatter index data |\n\nThe following substitutions are extracted from your project files and may or may not be used by the default\ntemplate:\n\n| Substitution name | Value |\n|:-------------------------------------|:-------------------------------|\n| \u0060fsdocs-copyright\u0060 | \u0060\u003CCopyright\u003E\u0060 |\n| \u0060fsdocs-package-project-url\u0060 | \u0060\u003CPackageProjectUrl\u003E\u0060 |\n| \u0060fsdocs-package-license-expression\u0060 | \u0060\u003CPackageLicenseExpression\u003E\u0060 |\n| \u0060fsdocs-package-tags\u0060 | \u0060\u003CPackageTags\u003E\u0060 |\n| \u0060fsdocs-package-version\u0060 | \u0060\u003CVersion\u003E\u0060 |\n\nFor the \u0060fsdocs\u0060 tool, additional substitutions can be specified using \u0060--parameters\u0060.\n\n## Cross References to API Docs\n\nMarkdown content can contain cross-references to API Docs. Use inline\nmarkdown code snippets of the special form \u0060\u0060 \u0060cref:T:MyNamespace.MyType\u0060 \u0060\u0060 where \u0060T:MyNamespace.MyType\u0060\nis a method, property or type xml doc sig reference, see [API Docs](apidocs.html).\nThis can include any cross-references resolved by fsdocs.\n\nThe generated API documentation includes buttons to copy the XML and Markdown forms of API doc references.\n\nFor example, within this project,\n\n- the text \u0060\u0060 \u0060cref:T:FSharp.Formatting.Markdown.MarkdownParagraph\u0060 \u0060\u0060 resolves to the link \u0060cref:T:FSharp.Formatting.Markdown.MarkdownParagraph\u0060\n\n- the text \u0060\u0060\u0060 \u0060cref:T:System.Console\u0060 \u0060\u0060\u0060 resolves to the link \u0060cref:T:System.Console\u0060\n\n- the text \u0060\u0060\u0060 \u0060cref:M:System.Console.WriteLine\u0060 \u0060\u0060\u0060 resolves to the link \u0060cref:M:System.Console.WriteLine\u0060\n\n- the text \u0060\u0060\u0060 \u0060cref:M:System.Console.WriteLine(System.String)\u0060 \u0060\u0060\u0060 resolves to the link \u0060cref:M:System.Console.WriteLine(System.String)\u0060\n\n- the text \u0060\u0060\u0060 \u0060\u0060cref:T:FSharp.Control.FSharpAsync\u00601\u0060\u0060 \u0060\u0060\u0060 resolves to the link \u0060\u0060cref:T:FSharp.Control.FSharpAsync\u00601\u0060\u0060\n\n- the text \u0060\u0060\u0060 \u0060cref:T:FSharp.Control.FSharpAsync\u0060 \u0060\u0060\u0060 resolves to the link \u0060cref:T:FSharp.Control.FSharpAsync\u0060\n\n- the text \u0060\u0060\u0060 \u0060\u0060cref:T:FSharp.Core.array\u00601\u0060\u0060 \u0060\u0060\u0060 resolves to the link \u0060\u0060cref:T:FSharp.Core.array\u00601\u0060\u0060\n\n- the text \u0060\u0060\u0060 \u0060cref:T:FSharp.Core.OptionModule\u0060 \u0060\u0060\u0060 resolves to the link \u0060cref:T:FSharp.Core.OptionModule\u0060\n\n- the text \u0060\u0060\u0060\u0060 \u0060\u0060\u0060cref:M:FSharp.Collections.ListModule.Append\u0060\u00601\u0060\u0060\u0060 \u0060\u0060\u0060\u0060 resolves to the link \u0060\u0060\u0060cref:M:FSharp.Collections.ListModule.Append\u0060\u00601\u0060\u0060\u0060\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\u003E external link. [Please report it](https://github.com/fsprojects/FSharp.Formatting/issues/new).\n\nDetermining xmldoc sig references is not simple. The API doc generated pages come with\nbuttons to copy out the XmlDoc signature.\n\n## Generating HTML Output\n\nHTML is generated by default. You can also add a \u0060_template.html\u0060. This should contain \u0060{{fsdocs-content}}\u0060, \u0060{{fsdocs-tooltips}}\u0060\nand other placeholders. Substitutions are\napplied to this template.\nIf a file \u0060_template.html\u0060 exists then is used as the template for HTML generation for that directory and all sub-content.\n\n## Generating LaTeX output\n\nTo generate .tex output for each script and markdown file, add a \u0060_template.tex\u0060. Substitutions are\napplied to this template. The file is either empty of contains \u0060{{fsdocs-content}}\u0060 as the key where the body\nof the document is placed.\n\n## Generating iPython Notebook output\n\nTo generate .ipynb output for each script and markdown file, add a \u0060_template.ipynb\u0060, usually empty. Substitutions are\napplied to this template.\n\nTo add a \u0060mybinder\u0060 badge to your generated notebook, ensure you have a \u0060Dockerfile\u0060 and \u0060NuGet.config\u0060\nin your \u0060docs\u0060 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\nTo generate .fsx output for each script and markdown file, add a \u0060_template.fsx\u0060, usually empty. Substitutions are\napplied to this template. It is either empty of contains \u0060{{fsdocs-content}}\u0060 as the key where the body\nof the script is placed.\n\n*)"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/upgrade.html","title":"Upgrading to fsdocs\n","content":"---\ncategory: Advanced\ncategoryindex: 3\nindex: 1\n---\n\n# Upgrading to fsdocs\n\nHere are the typical steps to upgrade a repo based on \u0060ProjectScaffold\u0060 to use \u0060fsdocs\u0060\n\n1. Run\n\n [lang=text]\n dotnet new tool\n dotnet tool install fsdocs-tool\n\n2. Delete all of \u0060docs\\tools\u0060 particularly \u0060docs\\tool\\generate.fsx\u0060. Keep a copy of any templates for reference as you\u0027ll have to copy some bits across to the new template.\n\n3. Put your docs directory so it reflects the final shape of the site. For example move the content of \u0060docs\\input\\*\u0060 and \u0060docs\\files\\*\u0060 directly to \u0060docs\\*\u0060\n\n4. Follow the notes in [styling](styling.html) to start to style your site.\n\n5. Run\n\n [lang=text]\n dotnet fsdocs watch\n\n and edit and test your docs.\n\n6. If using FAKE adjust \u0060build.fsx\u0060 e.g.\n\n [lang=text]\n Target.create \u0022GenerateDocs\u0022 (fun _ -\u003E\n Shell.cleanDir \u0022.fsdocs\u0022\n DotNet.exec id \u0022fsdocs\u0022 \u0022build --clean\u0022 |\u003E ignore\n )\n \n Target.create \u0022ReleaseDocs\u0022 (fun _ -\u003E\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 |\u003E printfn \u0022%A\u0022\n Git.CommandHelper.runSimpleGitCommand \u0022temp/gh-pages\u0022 \u0022add .\u0022 |\u003E 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 |\u003E printfn \u0022%s\u0022\n Git.Branches.push \u0022temp/gh-pages\u0022\n )\n\n7. Consider creating \u0060docs\\_template.fsx\u0060 and \u0060docs\\_template.ipynb\u0060 to enable co-generation of F# scripts and F# notebooks.\n\n 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).\n\n 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).\n\nSample commands: \n\n [lang=text]\n dotnet tool install fsdocs-tool --local\n git add dotnet-tools.json \n git rm -fr docs/tools\n git mv docs/input/* docs\n git mv docs/files/* docs\n \n \u003Cmanually download and fixup the _template.html\u003E\n\n dotnet fsdocs watch\n\n touch docs/_template.fsx\n touch docs/_template.ipynb\n git add docs/_template.fsx\n git add docs/_template.ipynb\n\nHere is an example PR: https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116\n\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/templates/leftside/styling.html","title":"Example: Styling for Right-Side Navigation Bar\n","content":"---\n# Example: Right-Side NavBar\ncategory: Examples\ncategoryindex: 2\nindex: 4\n---\n\n# Example: Styling for Right-Side Navigation Bar\n\nThe sidebar can be moved to the right by using \n\n \u0060\u003CFsDocsNavbarPosition\u003Efixed-right\u003CFsDocsNavbarPosition\u003E\u0060\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.\n\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\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/sidebyside/sidemarkdown.html","title":"Markdown Content","content":"---\ntitle: Markdown Content\ncategory: Examples\ncategoryindex: 2\nindex: 2\n---\n# Example: Using Markdown Content\n\nThis file demonstrates how to write Markdown document with \nembedded F# snippets that can be transformed into nice HTML \nusing the \u0060literate.fsx\u0060 script from the [F# Formatting\npackage](http://fsprojects.github.io/FSharp.Formatting).\n\nIn this case, the document itself is a valid Markdown and \nyou can use standard Markdown features to format the text:\n\n - Here is an example of unordered list and...\n - Text formatting including **bold** and _emphasis_\n\nFor more information, see the [Markdown][md] reference.\n\n [md]: http://daringfireball.net/projects/markdown\n\n\n## Writing F# code\n\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 \u0060\u003Cpre\u003E\u0060 element. If you do \nthe same using Literate F# tool, the code is turned into\na 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\nIf you want to include some code in the source code, \nbut omit it from the output, you can use the \u0060hide\u0060 \ncommand. You can also use \u0060module=...\u0060 to specify that \nthe 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\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:\n\n let answer = Hidden.answer\n\n## Including other snippets\n\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:\n\n [lang=csharp]\n Console.WriteLine(\u0022Hello world!\u0022);\n\nThis snippet is turned into a \u0060pre\u0060 element with the\n\u0060lang\u0060 attribute set to \u0060csharp\u0060.\n"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/sidebyside/sidescript.html","title":"Literate Script","content":"(**\n---\ntitle: Literate Script\ncategory: Examples\ncategoryindex: 2\nindex: 1\n---\n# Example: Using Literate Script Content\n\nThis file demonstrates how to write literate F# script\nfiles (\u0060*.fsx\u0060) that can be transformed into nice HTML\nusing the \u0060literate.fsx\u0060 script from the [F# Formatting\npackage](http://fsprojects.github.io/FSharp.Formatting).\n\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\n - Unordered or ordered lists\n - Text formatting including **bold** and _emphasis_\n\nAnd numerous other [Markdown][md] features.\n\n [md]: http://daringfireball.net/projects/markdown\n\n## Writing F# code\n\nCode that is not inside comment will be formatted as\na sample snippet.\n*)\n\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\n(**\nHiding code\n-----------\n\nIf you want to include some code in the source code,\nbut omit it from the output, you can use the \u0060hide\u0060\ncommand.\n*)\n\n(*** hide ***)\n/// This is a hidden answer\nlet hidden = 42\n\n(**\nThe value will be defined in the F# code and so you\ncan use it from other (visible) code and get correct\ntool tips:\n*)\n\nlet answer = hidden\n\n(**\n## Moving code around\n\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 \u0060include\u0060 and \u0060define\u0060 commands.\n\nThe following snippet gets correct tool tips, even though\nit uses \u0060laterFunction\u0060:\n*)\n\n(*** include:later-bit ***)\n\n(**\nThen we can explain how \u0060laterFunction\u0060 is defined:\n*)\n\nlet laterFunction () = \u0022Not very difficult, is it?\u0022\n\n(**\nThis example covers pretty much all features that are\ncurrently implemented in \u0060literate.fsx\u0060, but feel free\nto [fork the project on GitHub][fs] and add more\nfeatures or report bugs!\n\n [fs]: https://github.com/fsprojects/FSharp.Formatting\n\n*)\n\n(*** define:later-bit ***)\nlet sample = laterFunction () |\u003E printfn \u0022Got: %s\u0022"},{"uri":"https://fsprojects.github.io/FSharp.Formatting/sidebyside/sideextensions.html","title":"Markdown LaTeX","content":"---\ntitle: Markdown LaTeX\ncategory: Examples\ncategoryindex: 2\nindex: 3\n---\nExample: Using the Markdown Extensions for LaTeX\n===================\n\nTo use LaTex extension, you need add javascript\nlink to [MathJax](http://www.mathjax.org/) in\nyour template.\n\nTo use inline LaTex, eclose LaTex code with \u0060$\u0060:\n$ k_{n\u002B1} = n^2 \u002B k_n^2 - k_{n-1} $. Alternatively,\nyou can also use \u0060$$\u0060.\n\nTo use block LaTex, start a new parapgraph, with\nthe first line marked as \u0060$$$\u0060 (no close \u0060$$$\u0060):\n\n$$$\nA_{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\nUse LaTex escape rule:\n\n- Escape \\$ in inline mode: $ \\$ $, $ \\$var $\n- Other escapes: $ \\\u0026 \\% \\$ \\# \\_ \\{ \\} $\n- Using \u003C or \u003E: $ x \u003E 1 $, $ y \u003C 1 $, $ x \u003E= 1 $,\n $ y \u003C= 1 $, $ x = 1 $\n- $ \u003Cp\u003Esomething\u003C/p\u003E $\n\n\n"}]
\ 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.fsx b/literate.fsx
new file mode 100644
index 000000000..0a7d32143
--- /dev/null
+++ b/literate.fsx
@@ -0,0 +1,271 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,19.1.1"
+(**
+[](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,19.1.1"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,19.1.1"
+#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..d37d49252
--- /dev/null
+++ b/literate.html
@@ -0,0 +1,562 @@
+
+
+
+
+
+ Literate Scripts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+You must build your documentation with evaluation turned on using --eval.
+Substitutions
+Substitutions are applied to content, see content.
+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 <pre> HTML
+tag without any processing.
+
+
+LaTeX in Literate Scripts and Markdown Documents
+Literate Scripts may contain LaTeX sections in Markdown using these forms:
+
+Single line latex starting with $$.
A block delimited by \begin{equation}...\end{equation} or \begin{align}...\end{align}.
-
+
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
+\[\frac{x}{y}\]
+\[ \frac{d}{dx} \left. \left( x \left( \left. \frac{d}{dy} x y \; \right|_{y=3} \right) \right) \right|_{x=2}\]
+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,19.1.1"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,19.1.1"
+#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 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, 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:
+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
+
+ 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>
+Path.Combine([<System.ParamArray>] paths: string array) : string
Path.Combine(path1: string, path2: string) : string
Path.Combine(path1: string, path2: string, path3: string) : string
Path.Combine(path1: string, path2: string, path3: string, path4: string) : string
+val script: string
+type Literate =
+ static member ConvertMarkdownFile: input: string * ?template: string * ?output: string * ?outputKind: OutputKind * ?prefix: string * ?fscOptions: string * ?lineNumbers: bool * ?references: bool * ?substitutions: (ParamKey * string) list * ?generateAnchors: bool * ?imageSaver: (string -> string) * ?rootInputFolder: string * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?onError: (string -> unit) * ?filesWithFrontMatter: FrontMatterFile array -> unit
+ static member ConvertScriptFile: input: string * ?template: string * ?output: string * ?outputKind: OutputKind * ?prefix: string * ?fscOptions: string * ?lineNumbers: bool * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?substitutions: (ParamKey * string) list * ?generateAnchors: bool * ?imageSaver: (string -> string) * ?rootInputFolder: string * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?onError: (string -> unit) * ?filesWithFrontMatter: FrontMatterFile array -> unit
+ static member ParseAndCheckScriptFile: path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ParseMarkdownFile: path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ParseMarkdownString: content: string * ?path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ParseScriptString: content: string * ?path: string * ?fscOptions: string * ?definedSymbols: string list * ?references: bool * ?fsiEvaluator: IFsiEvaluator * ?parseOptions: MarkdownParseOptions * ?rootInputFolder: string * ?onError: (string -> unit) -> LiterateDocument
+ static member ToFsx: doc: LiterateDocument * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member ToHtml: doc: LiterateDocument * ?prefix: string * ?lineNumbers: bool * ?generateAnchors: bool * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?tokenKindToCss: (TokenKind -> string) -> string
+ static member ToLatex: doc: LiterateDocument * ?prefix: string * ?lineNumbers: bool * ?generateAnchors: bool * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member ToPynb: doc: LiterateDocument * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ ...
<summary>
+ This type provides three simple methods for calling the literate programming tool.
+ The <c>ConvertMarkdownFile</c> and <c>ConvertScriptFile</c> methods process a single Markdown document
+ and F# script, respectively. The <c>ConvertDirectory</c> method handles an entire directory tree
+ (looking for <c>*.fsx</c> and <c>*.md</c> files).
+ </summary>
<namespacedoc><summary>Functionality to support literate programming for F# scripts</summary></namespacedoc>
+static member Literate.ConvertScriptFile: input: string * ?template: string * ?output: string * ?outputKind: OutputKind * ?prefix: string * ?fscOptions: string * ?lineNumbers: bool * ?references: bool * ?fsiEvaluator: Evaluation.IFsiEvaluator * ?substitutions: (FSharp.Formatting.Templating.ParamKey * string) list * ?generateAnchors: bool * ?imageSaver: (string -> string) * ?rootInputFolder: string * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?onError: (string -> unit) * ?filesWithFrontMatter: FSharp.Formatting.Templating.FrontMatterFile array -> unit
+val doc: string
+static member Literate.ConvertMarkdownFile: input: string * ?template: string * ?output: string * ?outputKind: OutputKind * ?prefix: string * ?fscOptions: string * ?lineNumbers: bool * ?references: bool * ?substitutions: (FSharp.Formatting.Templating.ParamKey * string) list * ?generateAnchors: bool * ?imageSaver: (string -> string) * ?rootInputFolder: string * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?onError: (string -> unit) * ?filesWithFrontMatter: FSharp.Formatting.Templating.FrontMatterFile array -> unit
+val projTemplate: string
+val projInfo: (string * string) list
+val templateTex: string
+val scriptTex: string
+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..eeb54b1e8
--- /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,19.1.1\"\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,19.1.1\"\n",
+ "#endif // FSX\n",
+ " (*** condition: ipynb ***)\n",
+ "#if IPYNB\n",
+ " #r \"nuget: FSharp.Formatting,19.1.1\"\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..5e6b93e35
--- /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,19.1.1"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,19.1.1"
+#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..64d50ae91
--- /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,19.1.1"
+#endif // FSX
+ (*** condition: ipynb ***)
+#if IPYNB
+ #r "nuget: FSharp.Formatting,19.1.1"
+#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..686c18498
--- /dev/null
+++ b/markdown.fsx
@@ -0,0 +1,154 @@
+(**
+
+*)
+#r "nuget: FSharp.Formatting,19.1.1"
+(**
+[](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..fc7b6b764
--- /dev/null
+++ b/markdown.html
@@ -0,0 +1,357 @@
+
+
+
+
+
+ Markdown parser
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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
+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:
+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 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
+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.
+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 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
+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.
+Generating HTML output
+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:
+let html = Markdown.ToHtml(parsed)
+
+There are also methods to generate .fsx, .ipynb, .md and .tex.
+
+ Multiple items
namespace FSharp
--------------------
namespace Microsoft.FSharp
+namespace FSharp.Formatting
+namespace FSharp.Formatting.Markdown
+namespace FSharp.Formatting.Common
+val document: string
+val parsed: MarkdownDocument
+type Markdown =
+ static member Parse: text: string * ?newline: string * ?parseOptions: MarkdownParseOptions -> MarkdownDocument
+ static member ToFsx: doc: MarkdownDocument * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member ToHtml: doc: MarkdownDocument * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string + 1 overload
+ static member ToLatex: doc: MarkdownDocument * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?lineNumbers: bool -> string + 1 overload
+ static member ToMd: doc: MarkdownDocument * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member ToPynb: doc: MarkdownDocument * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+ static member WriteHtml: doc: MarkdownDocument * writer: TextWriter * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> unit + 1 overload
+ static member WriteLatex: doc: MarkdownDocument * writer: TextWriter * ?newline: string * ?substitutions: (ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) * ?lineNumbers: bool -> unit + 1 overload
<summary>
+ Static class that provides methods for formatting
+ and transforming Markdown documents.
+</summary>
+static member Markdown.Parse: text: string * ?newline: string * ?parseOptions: MarkdownParseOptions -> MarkdownDocument
+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
--------------------
active recognizer ParagraphLeaf: MarkdownParagraph -> Choice<MarkdownPatterns.ParagraphLeafInfo,(MarkdownPatterns.ParagraphNestedInfo * MarkdownParagraphs list),(MarkdownPatterns.ParagraphSpansInfo * MarkdownSpans)>
+Multiple items
val ParagraphNested: MarkdownPatterns.ParagraphNestedInfo * pars: MarkdownParagraphs list -> MarkdownParagraph
--------------------
active recognizer ParagraphNested: MarkdownParagraph -> Choice<MarkdownPatterns.ParagraphLeafInfo,(MarkdownPatterns.ParagraphNestedInfo * MarkdownParagraphs list),(MarkdownPatterns.ParagraphSpansInfo * MarkdownSpans)>
+val pars: MarkdownParagraphs list
+val ps: MarkdownParagraphs
+val p: MarkdownParagraph
+Multiple items
val ParagraphSpans: MarkdownPatterns.ParagraphSpansInfo * spans: MarkdownSpans -> MarkdownParagraph
--------------------
active recognizer ParagraphSpans: MarkdownParagraph -> Choice<MarkdownPatterns.ParagraphLeafInfo,(MarkdownPatterns.ParagraphNestedInfo * MarkdownParagraphs list),(MarkdownPatterns.ParagraphSpansInfo * MarkdownSpans)>
+module Seq
+
+from Microsoft.FSharp.Collections
+val collect: mapping: ('T -> #('U seq)) -> source: 'T seq -> 'U seq
+val html: string
+static member Markdown.ToHtml: markdownText: string * ?newline: string * ?substitutions: (FSharp.Formatting.Templating.ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
static member Markdown.ToHtml: doc: MarkdownDocument * ?newline: string * ?substitutions: (FSharp.Formatting.Templating.ParamKey * string) list * ?crefResolver: (string -> (string * string) option) * ?mdlinkResolver: (string -> string option) -> string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/markdown.ipynb b/markdown.ipynb
new file mode 100644
index 000000000..59c4350c2
--- /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,19.1.1\"\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..1397e51fe
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocattribute.html
@@ -0,0 +1,1159 @@
+
+
+
+
+
+ ApiDocAttribute (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocAttribute Type
+
+
+
+
+
+
+ Represents a custom attribute attached to source code
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocAttribute(name, fullName, constructorArguments, namedConstructorArguments)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocAttribute(name, fullName, constructorArguments, namedConstructorArguments)
+
+
+ Parameters:
+
+
+
+ name
+
+ :
+ string
+
+
+
+
+ fullName
+
+ :
+ string
+
+
+
+
+ constructorArguments
+
+ :
+ obj list
+
+
+
+
+ namedConstructorArguments
+
+ :
+ (string * obj) list
+
+
+
+
+
+ Returns:
+ ApiDocAttribute
+
+
+
+
+
+
+
+
+ -
+
+ name
+
+ :
+
string
+
+
+ -
+
+ fullName
+
+ :
+
string
+
+
+ -
+
+ constructorArguments
+
+ :
+
obj list
+
+
+ -
+
+ namedConstructorArguments
+
+ :
+
(string * obj) list
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocAttribute
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.ConstructorArguments
+
+
+
+ Returns:
+ obj list
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
obj list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.CustomOperationName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+ 
+ 
+
+
+ 
+ 
+
+
+
+ Returns the custom operation name, when this attribute is the CustomOperationAttribute. When its not an empty string is returned
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Format
+
+
+
+
+
+
+ Full Usage:
+ this.Format
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formats the attribute using the Name. Removes the "Attribute"-suffix. E.g Obsolete
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatFullName
+
+
+
+
+
+
+ Full Usage:
+ this.FormatFullName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formats the attribute using the FullName. Removes the "Attribute"-suffix. E.g System.Obsolete
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.FormatFullNameLongForm
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formats the attribute using the FullName. Keeps the "Attribute"-suffix. E.g System.ObsoleteAttribute
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatLongForm
+
+
+
+
+
+
+ Full Usage:
+ this.FormatLongForm
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formats the attribute using the Name. Keeps the "Attribute"-suffix. E.g ObsoleteAttribute
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FullName
+
+
+
+
+
+
+ Full Usage:
+ this.FullName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.IsCustomOperationAttribute
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets a value indicating whether this attribute the CustomOperationAttribute
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.IsObsoleteAttribute
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets a value indicating whether this attribute is System.ObsoleteAttribute
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.IsRequireQualifiedAccessAttribute
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets a value indicating whether this attribute is RequireQualifiedAccessAttribute
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Name
+
+
+
+
+
+
+ Full Usage:
+ this.Name
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.NamedConstructorArguments
+
+
+
+ Returns:
+ (string * obj) list
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(string * obj) list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ObsoleteMessage
+
+
+
+
+
+
+ Full Usage:
+ this.ObsoleteMessage
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the obsolete message, when this attribute is the System.ObsoleteAttribute. When its not or no message was specified, an empty string is returned
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidoccollection.html b/reference/fsharp-formatting-apidocs-apidoccollection.html
new file mode 100644
index 000000000..ee825c148
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidoccollection.html
@@ -0,0 +1,523 @@
+
+
+
+
+
+ ApiDocCollection (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocCollection Type
+
+
+
+
+
+
+ Represents a group of assemblies integrated with its associated documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ ApiDocCollection(name, asms, nss)
+
+
+ Parameters:
+
+
+
+ name
+
+ :
+ string
+
+
+
+
+ asms
+
+ :
+ AssemblyName list
+
+
+
+
+ nss
+
+ :
+ ApiDocNamespace list
+
+
+
+
+
+ Returns:
+ ApiDocCollection
+
+
+
+
+
+
+
+
+ -
+
+ name
+
+ :
+
string
+
+
+ -
+
+ asms
+
+ :
+
AssemblyName list
+
+
+ -
+
+ nss
+
+ :
+
ApiDocNamespace list
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocCollection
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Assemblies
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
AssemblyName list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CollectionName
+
+
+
+
+
+
+ Full Usage:
+ this.CollectionName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Namespaces
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocNamespace list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidoccomment.html b/reference/fsharp-formatting-apidocs-apidoccomment.html
new file mode 100644
index 000000000..57211c502
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidoccomment.html
@@ -0,0 +1,991 @@
+
+
+
+
+
+ ApiDocComment (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocComment Type
+
+
+
+
+
+
+ Represents a documentation comment attached to source code
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocComment(xmldoc, summary, remarks, parameters, returns, examples, notes, exceptions, rawData)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocComment(xmldoc, summary, remarks, parameters, returns, examples, notes, exceptions, rawData)
+
+
+ Parameters:
+
+
+
+ xmldoc
+
+ :
+ XElement option
+
+
+
+
+ summary
+
+ :
+ ApiDocHtml
+
+
+
+
+ remarks
+
+ :
+ ApiDocHtml option
+
+
+
+
+ parameters
+
+ :
+ (string * ApiDocHtml) list
+
+
+
+
+ returns
+
+ :
+ ApiDocHtml option
+
+
+
+
+ examples
+
+ :
+ ApiDocHtml list
+
+
+
+
+ notes
+
+ :
+ ApiDocHtml list
+
+
+
+
+ exceptions
+
+ :
+ (string * string option * ApiDocHtml) list
+
+
+
+
+ rawData
+
+ :
+ KeyValuePair<string, string> list
+
+
+
+
+
+ Returns:
+ ApiDocComment
+
+
+
+
+
+
+
+
+ -
+
+ xmldoc
+
+ :
+
XElement option
+
+
+ -
+
+ summary
+
+ :
+
ApiDocHtml
+
+
+ -
+
+ remarks
+
+ :
+
ApiDocHtml option
+
+
+ -
+
+ parameters
+
+ :
+
(string * ApiDocHtml) list
+
+
+ -
+
+ returns
+
+ :
+
ApiDocHtml option
+
+
+ -
+
+ examples
+
+ :
+
ApiDocHtml list
+
+
+ -
+
+ notes
+
+ :
+
ApiDocHtml list
+
+
+ -
+
+ exceptions
+
+ :
+
(string * string option * ApiDocHtml) list
+
+
+ -
+
+ rawData
+
+ :
+
KeyValuePair<string, string> list
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocComment
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Examples
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Exceptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(string * string option * ApiDocHtml) list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Notes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Parameters
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(string * ApiDocHtml) list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.RawData
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
KeyValuePair<string, string> list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Remarks
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Returns
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Summary
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocentity.html b/reference/fsharp-formatting-apidocs-apidocentity.html
new file mode 100644
index 000000000..60fbc8c42
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocentity.html
@@ -0,0 +1,2995 @@
+
+
+
+
+
+ ApiDocEntity (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntity Type
+
+
+
+
+
+
+ Represents a type definition integrated with its associated documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntity(tdef, name, cat, catidx, exclude, urlBaseName, comment, assembly, attributes, cases, fields, statParams, ctors, inst, stat, allInterfaces, baseType, abbreviatedType, delegateSignature, symbol, nested, vals, exts, pats, rqa, location, substitutions)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocEntity(tdef, name, cat, catidx, exclude, urlBaseName, comment, assembly, attributes, cases, fields, statParams, ctors, inst, stat, allInterfaces, baseType, abbreviatedType, delegateSignature, symbol, nested, vals, exts, pats, rqa, location, substitutions)
+
+
+ Parameters:
+
+
+
+ tdef
+
+ :
+ bool
+
+
+
+
+ name
+
+ :
+ string
+
+
+
+
+ cat
+
+ :
+ string
+
+
+
+
+ catidx
+
+ :
+ int
+
+
+
+
+ exclude
+
+ :
+ bool
+
+
+
+
+ urlBaseName
+
+ :
+ string
+
+
+
+
+ comment
+
+ :
+ ApiDocComment
+
+
+
+
+ assembly
+
+ :
+ AssemblyName
+
+
+
+
+ attributes
+
+ :
+ ApiDocAttribute list
+
+
+
+
+ cases
+
+ :
+ ApiDocMember list
+
+
+
+
+ fields
+
+ :
+ ApiDocMember list
+
+
+
+
+ statParams
+
+ :
+ ApiDocMember list
+
+
+
+
+ ctors
+
+ :
+ ApiDocMember list
+
+
+
+
+ inst
+
+ :
+ ApiDocMember list
+
+
+
+
+ stat
+
+ :
+ ApiDocMember list
+
+
+
+
+ allInterfaces
+
+ :
+ (FSharpType * ApiDocHtml) list
+
+
+
+
+ baseType
+
+ :
+ (FSharpType * ApiDocHtml) option
+
+
+
+
+ abbreviatedType
+
+ :
+ (FSharpType * ApiDocHtml) option
+
+
+
+
+ delegateSignature
+
+ :
+ (FSharpDelegateSignature * ApiDocHtml) option
+
+
+
+
+ symbol
+
+ :
+ FSharpEntity
+
+
+
+
+ nested
+
+ :
+ ApiDocEntity list
+
+
+
+
+ vals
+
+ :
+ ApiDocMember list
+
+
+
+
+ exts
+
+ :
+ ApiDocMember list
+
+
+
+
+ pats
+
+ :
+ ApiDocMember list
+
+
+
+
+ rqa
+
+ :
+ bool
+
+
+
+
+ location
+
+ :
+ string option
+
+
+
+
+ substitutions
+
+ :
+ Substitutions
+
+
+
+
+
+ Returns:
+ ApiDocEntity
+
+
+
+
+
+
+
+
+ -
+
+ tdef
+
+ :
+
bool
+
+
+ -
+
+ name
+
+ :
+
string
+
+
+ -
+
+ cat
+
+ :
+
string
+
+
+ -
+
+ catidx
+
+ :
+
int
+
+
+ -
+
+ exclude
+
+ :
+
bool
+
+
+ -
+
+ urlBaseName
+
+ :
+
string
+
+
+ -
+
+ comment
+
+ :
+
ApiDocComment
+
+
+ -
+
+ assembly
+
+ :
+
AssemblyName
+
+
+ -
+
+ attributes
+
+ :
+
ApiDocAttribute list
+
+
+ -
+
+ cases
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ fields
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ statParams
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ ctors
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ inst
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ stat
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ allInterfaces
+
+ :
+
(FSharpType * ApiDocHtml) list
+
+
+ -
+
+ baseType
+
+ :
+
(FSharpType * ApiDocHtml) option
+
+
+ -
+
+ abbreviatedType
+
+ :
+
(FSharpType * ApiDocHtml) option
+
+
+ -
+
+ delegateSignature
+
+ :
+
(FSharpDelegateSignature * ApiDocHtml) option
+
+
+ -
+
+ symbol
+
+ :
+
FSharpEntity
+
+
+ -
+
+ nested
+
+ :
+
ApiDocEntity list
+
+
+ -
+
+ vals
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ exts
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ pats
+
+ :
+
ApiDocMember list
+
+
+ -
+
+ rqa
+
+ :
+
bool
+
+
+ -
+
+ location
+
+ :
+
string option
+
+
+ -
+
+ substitutions
+
+ :
+
Substitutions
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntity
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.AbbreviatedType
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(FSharpType * ApiDocHtml) option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ActivePatterns
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.AllInterfaces
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(FSharpType * ApiDocHtml) list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.AllMembers
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Assembly
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
AssemblyName
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Attributes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocAttribute list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.BaseType
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(FSharpType * ApiDocHtml) option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Category
+
+
+
+
+
+
+ Full Usage:
+ this.Category
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CategoryIndex
+
+
+
+
+
+
+ Full Usage:
+ this.CategoryIndex
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Comment
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocComment
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Constructors
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.DelegateSignature
+
+
+
+
+
+
+ Full Usage:
+ this.DelegateSignature
+
+
+
+ Returns:
+ (FSharpDelegateSignature * ApiDocHtml) option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(FSharpDelegateSignature * ApiDocHtml) option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Exclude
+
+
+
+
+
+
+ Full Usage:
+ this.Exclude
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.InstanceMembers
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsObsolete
+
+
+
+
+
+
+ Full Usage:
+ this.IsObsolete
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsTypeDefinition
+
+
+
+
+
+
+ Full Usage:
+ this.IsTypeDefinition
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Name
+
+
+
+
+
+
+ Full Usage:
+ this.Name
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.NestedEntities
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntity list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ObsoleteMessage
+
+
+
+
+
+
+ Full Usage:
+ this.ObsoleteMessage
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the obsolete message, when this member is obsolete. When its not or no message was specified, an empty string is returned
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.OutputFile
+
+
+
+
+
+
+ Full Usage:
+ this.OutputFile
+
+
+ Parameters:
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.RecordFields
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.RequiresQualifiedAccess
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.SourceLocation
+
+
+
+
+
+
+ Full Usage:
+ this.SourceLocation
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StaticMembers
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StaticParameters
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Symbol
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
FSharpEntity
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.TypeExtensions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.UnionCases
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Url
+
+
+
+
+
+
+ Full Usage:
+ this.Url
+
+
+ Parameters:
+
+
+
+ root
+
+ :
+ string
+
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL of the best link for the entity relative to "reference" directory (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ root
+
+ :
+
string
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.UrlBaseName
+
+
+
+
+
+
+ Full Usage:
+ this.UrlBaseName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL base name of the primary documentation for the entity (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ValuesAndFuncs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember list
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntity.GetUrl(urlBaseName, root, collectionName, qualify, extension)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocEntity.GetUrl(urlBaseName, root, collectionName, qualify, extension)
+
+
+ Parameters:
+
+
+
+ urlBaseName
+
+ :
+ string
+
+
+
+
+ root
+
+ :
+ string
+
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compute the URL of the best link for the entity relative to "reference" directory (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ urlBaseName
+
+ :
+
string
+
+
+ -
+
+ root
+
+ :
+
string
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocentityinfo.html b/reference/fsharp-formatting-apidocs-apidocentityinfo.html
new file mode 100644
index 000000000..21a01bf62
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocentityinfo.html
@@ -0,0 +1,601 @@
+
+
+
+
+
+ ApiDocEntityInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntityInfo Type
+
+
+
+
+
+
+ High-level information about a module definition
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntityInfo(entity, collection, ns, parent)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocEntityInfo(entity, collection, ns, parent)
+
+
+ Parameters:
+
+
+
+ entity
+
+ :
+ ApiDocEntity
+
+
+
+
+ collection
+
+ :
+ ApiDocCollection
+
+
+
+
+ ns
+
+ :
+ ApiDocNamespace
+
+
+
+
+ parent
+
+ :
+ ApiDocEntity option
+
+
+
+
+
+ Returns:
+ ApiDocEntityInfo
+
+
+
+
+
+
+
+
+ -
+
+ entity
+
+ :
+
ApiDocEntity
+
+
+ -
+
+ collection
+
+ :
+
ApiDocCollection
+
+
+ -
+
+ ns
+
+ :
+
ApiDocNamespace
+
+
+ -
+
+ parent
+
+ :
+
ApiDocEntity option
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntityInfo
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Collection
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocCollection
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Entity
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntity
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Namespace
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocNamespace
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ParentModule
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntity option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocfileextensions.html b/reference/fsharp-formatting-apidocs-apidocfileextensions.html
new file mode 100644
index 000000000..60fbf8722
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocfileextensions.html
@@ -0,0 +1,314 @@
+
+
+
+
+
+ ApiDocFileExtensions (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocFileExtensions Type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ InFile
+
+
+
+
+
+
+ Full Usage:
+ InFile
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidochtml.html b/reference/fsharp-formatting-apidocs-apidochtml.html
new file mode 100644
index 000000000..eead8568a
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidochtml.html
@@ -0,0 +1,445 @@
+
+
+
+
+
+ ApiDocHtml (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocHtml Type
+
+
+
+
+
+
+ Represents some HTML formatted by model generation
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocHtml(html, id)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocHtml(html, id)
+
+
+ Parameters:
+
+
+
+ html
+
+ :
+ string
+
+
+
+
+ id
+
+ :
+ string option
+
+
+
+
+
+ Returns:
+ ApiDocHtml
+
+
+
+
+
+
+
+
+ -
+
+ html
+
+ :
+
string
+
+
+ -
+
+ id
+
+ :
+
string option
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.HtmlText
+
+
+
+
+
+
+ Full Usage:
+ this.HtmlText
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Id
+
+
+
+
+
+
+ Full Usage:
+ this.Id
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocinput.html b/reference/fsharp-formatting-apidocs-apidocinput.html
new file mode 100644
index 000000000..1d0095b99
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocinput.html
@@ -0,0 +1,847 @@
+
+
+
+
+
+ ApiDocInput (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocInput Type
+
+
+
+
+
+
+ Represents an input assembly for API doc generation
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownComments
+
+
+
+
+
+
+ Full Usage:
+ MarkdownComments
+
+
+
+ Field type:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Whether the input uses markdown comments
+
+
+
+
+
+ -
+
+ Field type:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The path to the assembly
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PublicOnly
+
+
+
+
+
+
+ Full Usage:
+ PublicOnly
+
+
+
+ Field type:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Whether to generate only public things
+
+
+
+
+
+ -
+
+ Field type:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SourceFolder
+
+
+
+
+
+
+ Full Usage:
+ SourceFolder
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The compile-time source folder
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SourceRepo
+
+
+
+
+
+
+ Full Usage:
+ SourceRepo
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL the the source repo where the source code lives
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+ -
+
+ Field type:
+
+
Substitutions option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Whether doc processing should warn on missing comments
+
+
+
+
+
+ -
+
+ Field type:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ XmlFile
+
+
+
+
+
+
+ Full Usage:
+ XmlFile
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Override the default XML file (normally assumed to live alongside)
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocInput.FromFile(assemblyPath, ?mdcomments, ?substitutions, ?sourceRepo, ?sourceFolder, ?publicOnly, ?warn)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocInput.FromFile(assemblyPath, ?mdcomments, ?substitutions, ?sourceRepo, ?sourceFolder, ?publicOnly, ?warn)
+
+
+ Parameters:
+
+
+
+ assemblyPath
+
+ :
+ string
+
+
+
+
+ ?mdcomments
+
+ :
+ bool
+
+
+
+
+ ?substitutions
+
+ :
+ Substitutions
+
+
+
+
+ ?sourceRepo
+
+ :
+ string
+
+
+
+
+ ?sourceFolder
+
+ :
+ string
+
+
+
+
+ ?publicOnly
+
+ :
+ bool
+
+
+
+
+ ?warn
+
+ :
+ bool
+
+
+
+
+
+ Returns:
+ ApiDocInput
+
+
+
+
+
+
+
+
+ -
+
+ assemblyPath
+
+ :
+
string
+
+
+ -
+
+ ?mdcomments
+
+ :
+
bool
+
+
+ -
+
+ ?substitutions
+
+ :
+
Substitutions
+
+
+ -
+
+ ?sourceRepo
+
+ :
+
string
+
+
+ -
+
+ ?sourceFolder
+
+ :
+
string
+
+
+ -
+
+ ?publicOnly
+
+ :
+
bool
+
+
+ -
+
+ ?warn
+
+ :
+
bool
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocInput
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocmember.html b/reference/fsharp-formatting-apidocs-apidocmember.html
new file mode 100644
index 000000000..b3daf2dcd
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocmember.html
@@ -0,0 +1,2307 @@
+
+
+
+
+
+ ApiDocMember (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMember Type
+
+
+
+
+
+
+ Represents an method, property, constructor, function or value, record field, union case or static parameter
+ integrated with its associated documentation. Includes extension members.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMember(displayName, attributes, entityUrlBaseName, kind, cat, catidx, exclude, details, comment, symbol, warn)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocMember(displayName, attributes, entityUrlBaseName, kind, cat, catidx, exclude, details, comment, symbol, warn)
+
+
+ Parameters:
+
+
+
+ displayName
+
+ :
+ string
+
+
+
+
+ attributes
+
+ :
+ ApiDocAttribute list
+
+
+
+
+ entityUrlBaseName
+
+ :
+ string
+
+
+
+
+ kind
+
+ :
+ ApiDocMemberKind
+
+
+
+
+ cat
+
+ :
+ string
+
+
+
+
+ catidx
+
+ :
+ int
+
+
+
+
+ exclude
+
+ :
+ bool
+
+
+
+
+ details
+
+ :
+ ApiDocMemberDetails
+
+
+
+
+ comment
+
+ :
+ ApiDocComment
+
+
+
+
+ symbol
+
+ :
+ FSharpSymbol
+
+
+
+
+ warn
+
+ :
+ bool
+
+
+
+
+
+ Returns:
+ ApiDocMember
+
+
+
+
+
+
+
+
+ -
+
+ displayName
+
+ :
+
string
+
+
+ -
+
+ attributes
+
+ :
+
ApiDocAttribute list
+
+
+ -
+
+ entityUrlBaseName
+
+ :
+
string
+
+
+ -
+
+ kind
+
+ :
+
ApiDocMemberKind
+
+
+ -
+
+ cat
+
+ :
+
string
+
+
+ -
+
+ catidx
+
+ :
+
int
+
+
+ -
+
+ exclude
+
+ :
+
bool
+
+
+ -
+
+ details
+
+ :
+
ApiDocMemberDetails
+
+
+ -
+
+ comment
+
+ :
+
ApiDocComment
+
+
+ -
+
+ symbol
+
+ :
+
FSharpSymbol
+
+
+ -
+
+ warn
+
+ :
+
bool
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMember
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Attributes
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocAttribute list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Category
+
+
+
+
+
+
+ Full Usage:
+ this.Category
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CategoryIndex
+
+
+
+
+
+
+ Full Usage:
+ this.CategoryIndex
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Comment
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocComment
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CompiledName
+
+
+
+
+
+
+ Full Usage:
+ this.CompiledName
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.CustomOperationName
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the custom operation name, when this attribute is the CustomOperationAttribute.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Details
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMemberDetails
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Exclude
+
+
+
+
+
+
+ Full Usage:
+ this.Exclude
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ExtendedType
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(FSharpEntity * ApiDocHtml) option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatCompiledName
+
+
+
+
+
+
+ Full Usage:
+ this.FormatCompiledName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatModifiers
+
+
+
+
+
+
+ Full Usage:
+ this.FormatModifiers
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.FormatTypeArguments
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsObsolete
+
+
+
+
+
+
+ Full Usage:
+ this.IsObsolete
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.IsRequireQualifiedAccessAttribute
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Kind
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Modifiers
+
+
+
+
+
+
+ Full Usage:
+ this.Modifiers
+
+
+
+ Returns:
+ string list
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Name
+
+
+
+
+
+
+ Full Usage:
+ this.Name
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ObsoleteMessage
+
+
+
+
+
+
+ Full Usage:
+ this.ObsoleteMessage
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the obsolete message, when this member is obsolete. When its not or no message was specified, an empty string is returned
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Parameters
+
+
+
+
+
+
+ Full Usage:
+ this.Parameters
+
+
+
+ Returns:
+ (type) list
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(type) list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ReturnInfo
+
+
+
+
+
+
+ Full Usage:
+ this.ReturnInfo
+
+
+
+ Returns:
+ (type)
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(type)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.SourceLocation
+
+
+
+
+
+
+ Full Usage:
+ this.SourceLocation
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Symbol
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
FSharpSymbol
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.TypeArguments
+
+
+
+
+
+
+ Full Usage:
+ this.TypeArguments
+
+
+
+ Returns:
+ string list
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Url
+
+
+
+
+
+
+ Full Usage:
+ this.Url
+
+
+ Parameters:
+
+
+
+ root
+
+ :
+ string
+
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL of the best link documentation for the item relative to "reference" directory (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ root
+
+ :
+
string
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.UrlBaseName
+
+
+
+
+
+
+ Full Usage:
+ this.UrlBaseName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL base name of the best link documentation for the item (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.UsageHtml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocHtml
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMember.GetUrl(entityUrlBaseName, displayName, root, collectionName, qualify, extension)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocMember.GetUrl(entityUrlBaseName, displayName, root, collectionName, qualify, extension)
+
+
+ Parameters:
+
+
+
+ entityUrlBaseName
+
+ :
+ string
+
+
+
+
+ displayName
+
+ :
+ string
+
+
+
+
+ root
+
+ :
+ string
+
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL of the best link documentation for the item relative to "reference" directory (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ entityUrlBaseName
+
+ :
+
string
+
+
+ -
+
+ displayName
+
+ :
+
string
+
+
+ -
+
+ root
+
+ :
+
string
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocmemberdetails.html b/reference/fsharp-formatting-apidocs-apidocmemberdetails.html
new file mode 100644
index 000000000..6860e25df
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocmemberdetails.html
@@ -0,0 +1,389 @@
+
+
+
+
+
+ ApiDocMemberDetails (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMemberDetails Type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMemberDetails(usageHtml, paramTypes, returnType, modifiers, typars, extendedType, location, compiledName)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocMemberDetails(usageHtml, paramTypes, returnType, modifiers, typars, extendedType, location, compiledName)
+
+
+ Parameters:
+
+
+
+ usageHtml
+
+ :
+ ApiDocHtml
+
+
+
+
+ paramTypes
+
+ :
+ (Choice<FSharpParameter, FSharpField> * string * ApiDocHtml) list
+
+
+
+
+ returnType
+
+ :
+ (FSharpType * ApiDocHtml) option
+
+
+
+
+ modifiers
+
+ :
+ string list
+
+
+
+
+ typars
+
+ :
+ string list
+
+
+
+
+ extendedType
+
+ :
+ (FSharpEntity * ApiDocHtml) option
+
+
+
+
+ location
+
+ :
+ string option
+
+
+
+
+ compiledName
+
+ :
+ string option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ usageHtml
+
+ :
+
ApiDocHtml
+
+
+ -
+
+ paramTypes
+
+ :
+
(Choice<FSharpParameter, FSharpField> * string * ApiDocHtml) list
+
+
+ -
+
+ returnType
+
+ :
+
(FSharpType * ApiDocHtml) option
+
+
+ -
+
+ modifiers
+
+ :
+
string list
+
+
+ -
+
+ typars
+
+ :
+
string list
+
+
+ -
+
+ extendedType
+
+ :
+
(FSharpEntity * ApiDocHtml) option
+
+
+ -
+
+ location
+
+ :
+
string option
+
+
+ -
+
+ compiledName
+
+ :
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocmemberkind.html b/reference/fsharp-formatting-apidocs-apidocmemberkind.html
new file mode 100644
index 000000000..e18c1d734
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocmemberkind.html
@@ -0,0 +1,618 @@
+
+
+
+
+
+ ApiDocMemberKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMemberKind Type
+
+
+
+
+
+
+ Represents the kind of member
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ActivePattern
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructor
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ InstanceMember
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ RecordField
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ StaticMember
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ StaticParameter
+
+
+
+
+
+
+ Full Usage:
+ StaticParameter
+
+
+
+ Field type:
+ ApiDocMemberKind
+
+
+ Modifiers:
+ static
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ TypeExtension
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ UnionCase
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+ ValueOrFunction
+
+
+
+
+
+
+ Full Usage:
+ ValueOrFunction
+
+
+
+ Field type:
+ ApiDocMemberKind
+
+
+ Modifiers:
+ static
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocmodel.html b/reference/fsharp-formatting-apidocs-apidocmodel.html
new file mode 100644
index 000000000..6c0cb870c
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocmodel.html
@@ -0,0 +1,846 @@
+
+
+
+
+
+ ApiDocModel (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocModel Type
+
+
+
+
+
+
+ Represents a set of assemblies integrated with their associated documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Collection
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocCollection
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.EntityInfos
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntityInfo list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FileExtensions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocFileExtensions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IndexFileUrl
+
+
+
+
+
+
+ Full Usage:
+ this.IndexFileUrl
+
+
+ Parameters:
+
+
+
+ root
+
+ :
+ string
+
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ URL of the 'index.html' for the reference documentation for the model
+
+
+
+
+
+ -
+
+ root
+
+ :
+
string
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IndexOutputFile
+
+
+
+
+
+
+ Full Usage:
+ this.IndexOutputFile
+
+
+ Parameters:
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ URL of the 'index.html' for the reference documentation for the model
+
+
+
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Qualify
+
+
+
+
+
+
+ Full Usage:
+ this.Qualify
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Indicates if each collection is being qualified by its collection name, e.g. 'reference/FSharp.Core'
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Root
+
+
+
+
+
+
+ Full Usage:
+ this.Root
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The substitutions. Different substitutions can also be used for each specific input
+
+
+
+
+
+ -
+
+ Returns:
+
+
Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocnamespace.html b/reference/fsharp-formatting-apidocs-apidocnamespace.html
new file mode 100644
index 000000000..d2f920f81
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocnamespace.html
@@ -0,0 +1,973 @@
+
+
+
+
+
+ ApiDocNamespace (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocNamespace Type
+
+
+
+
+
+
+ Represents a namespace integrated with its associated documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocNamespace(name, modifiers, substitutions, nsdocs)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocNamespace(name, modifiers, substitutions, nsdocs)
+
+
+ Parameters:
+
+
+
+ name
+
+ :
+ string
+
+
+
+
+ modifiers
+
+ :
+ ApiDocEntity list
+
+
+
+
+ substitutions
+
+ :
+ Substitutions
+
+
+
+
+ nsdocs
+
+ :
+ ApiDocComment option
+
+
+
+
+
+ Returns:
+ ApiDocNamespace
+
+
+
+
+
+
+
+
+ -
+
+ name
+
+ :
+
string
+
+
+ -
+
+ modifiers
+
+ :
+
ApiDocEntity list
+
+
+ -
+
+ substitutions
+
+ :
+
Substitutions
+
+
+ -
+
+ nsdocs
+
+ :
+
ApiDocComment option
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocNamespace
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Entities
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocEntity list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Name
+
+
+
+
+
+
+ Full Usage:
+ this.Name
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.NamespaceDocs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocComment option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.OutputFile
+
+
+
+
+
+
+ Full Usage:
+ this.OutputFile
+
+
+ Parameters:
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The substitution substitutions active for generating thist content
+
+
+
+
+
+ -
+
+ Returns:
+
+
Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Url
+
+
+
+
+
+
+ Full Usage:
+ this.Url
+
+
+ Parameters:
+
+
+
+ root
+
+ :
+ string
+
+
+
+
+ collectionName
+
+ :
+ string
+
+
+
+
+ qualify
+
+ :
+ bool
+
+
+
+
+ extension
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The URL of the best link documentation for the item (without the http://site.io/reference)
+
+
+
+
+
+ -
+
+ root
+
+ :
+
string
+
+
+ -
+
+ collectionName
+
+ :
+
string
+
+
+ -
+
+ qualify
+
+ :
+
bool
+
+
+ -
+
+ extension
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.UrlBaseName
+
+
+
+
+
+
+ Full Usage:
+ this.UrlBaseName
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.UrlHash
+
+
+
+
+
+
+ Full Usage:
+ this.UrlHash
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocs.html b/reference/fsharp-formatting-apidocs-apidocs.html
new file mode 100644
index 000000000..d220c034e
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocs.html
@@ -0,0 +1,1215 @@
+
+
+
+
+
+ ApiDocs (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocs Type
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocs.GenerateHtml(inputs, output, collectionName, substitutions, ?template, ?root, ?qualify, ?libDirs, ?otherFlags, ?urlRangeHighlight, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocs.GenerateHtml(inputs, output, collectionName, substitutions, ?template, ?root, ?qualify, ?libDirs, ?otherFlags, ?urlRangeHighlight, ?onError)
+
+
+ Parameters:
+
+
+
+ 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
+
+
+
+
+
+ Returns:
+ ApiDocModel * ApiDocsSearchIndexEntry[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generates default HTML pages for the assemblies specified by the `inputs` parameter
+
+
+
+
+
+ -
+
+ 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
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocModel * ApiDocsSearchIndexEntry[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocs.GenerateMarkdown(inputs, output, collectionName, substitutions, ?template, ?root, ?qualify, ?libDirs, ?otherFlags, ?urlRangeHighlight, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocs.GenerateMarkdown(inputs, output, collectionName, substitutions, ?template, ?root, ?qualify, ?libDirs, ?otherFlags, ?urlRangeHighlight, ?onError)
+
+
+ Parameters:
+
+
+
+ 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
+
+
+
+
+
+ Returns:
+ ApiDocModel * ApiDocsSearchIndexEntry[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generates default Markdown pages for the assemblies specified by the `inputs` parameter
+
+
+
+
+
+ -
+
+ 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
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocModel * ApiDocsSearchIndexEntry[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocs.GenerateModel(inputs, collectionName, substitutions, ?qualify, ?libDirs, ?otherFlags, ?root, ?urlRangeHighlight, ?onError, ?extension)
+
+
+
+
+
+
+ Full Usage:
+ ApiDocs.GenerateModel(inputs, collectionName, substitutions, ?qualify, ?libDirs, ?otherFlags, ?root, ?urlRangeHighlight, ?onError, ?extension)
+
+
+ Parameters:
+
+
+
+ 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
+
+
+
+
+
+ Returns:
+ ApiDocModel
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generates a documentation model for the assemblies specified by the `inputs` parameter
+
+
+
+
+
+ -
+
+ 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
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocModel
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ ApiDocs.SearchIndexEntriesForModel(model)
+
+
+ Parameters:
+
+
+
+ model
+
+ :
+ ApiDocModel
+ -
+ the model for documentation
+
+
+
+
+
+ Returns:
+ ApiDocsSearchIndexEntry[]
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ model
+
+ :
+
ApiDocModel
+
+ -
+
+ the model for documentation
+
+
+
+
+ -
+
+ Returns:
+
+
ApiDocsSearchIndexEntry[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html b/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html
new file mode 100644
index 000000000..8b98a7069
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidocssearchindexentry.html
@@ -0,0 +1,355 @@
+
+
+
+
+
+ ApiDocsSearchIndexEntry (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocsSearchIndexEntry Type
+
+
+
+
+
+
+ Represents an entry suitable for constructing a Lunr index
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ content
+
+
+
+
+
+
+ Full Usage:
+ content
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-apidoctype.html b/reference/fsharp-formatting-apidocs-apidoctype.html
new file mode 100644
index 000000000..159af887e
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-apidoctype.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ ApiDocType (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-attribute.html b/reference/fsharp-formatting-apidocs-attribute.html
new file mode 100644
index 000000000..a6a50664a
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-attribute.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ Attribute (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-doccomment.html b/reference/fsharp-formatting-apidocs-doccomment.html
new file mode 100644
index 000000000..c0d3236ff
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-doccomment.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ DocComment (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-member.html b/reference/fsharp-formatting-apidocs-member.html
new file mode 100644
index 000000000..a51accf89
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-member.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ Member (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-memberkind.html b/reference/fsharp-formatting-apidocs-memberkind.html
new file mode 100644
index 000000000..b1b538a53
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-memberkind.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ MemberKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-module.html b/reference/fsharp-formatting-apidocs-module.html
new file mode 100644
index 000000000..5b5b11621
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-module.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ Module (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-moduleinfo.html b/reference/fsharp-formatting-apidocs-moduleinfo.html
new file mode 100644
index 000000000..7d37fc4df
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-moduleinfo.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ ModuleInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-type.html b/reference/fsharp-formatting-apidocs-type.html
new file mode 100644
index 000000000..ad48cadef
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-type.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ Type (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs-typeinfo.html b/reference/fsharp-formatting-apidocs-typeinfo.html
new file mode 100644
index 000000000..6281ab6a2
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs-typeinfo.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+ TypeInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-apidocs.html b/reference/fsharp-formatting-apidocs.html
new file mode 100644
index 000000000..acd2bb87c
--- /dev/null
+++ b/reference/fsharp-formatting-apidocs.html
@@ -0,0 +1,672 @@
+
+
+
+
+
+ FSharp.Formatting.ApiDocs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.ApiDocs Namespace
+
+
+
+ Functionality relating to generating API documentation
+
+
+
+
+
+
+ Type
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ ApiDocAttribute
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocCollection
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a group of assemblies integrated with its associated documentation
+
+
+
+
+
+
+
+
+
+
+ ApiDocComment
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntity
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a type definition integrated with its associated documentation
+
+
+
+
+
+
+
+
+
+
+ ApiDocEntityInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocFileExtensions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocHtml
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocInput
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMember
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents an method, property, constructor, function or value, record field, union case or static parameter
+ integrated with its associated documentation. Includes extension members.
+
+
+
+
+
+
+
+
+
+
+ ApiDocMemberDetails
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocMemberKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ApiDocModel
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a set of assemblies integrated with their associated documentation
+
+
+
+
+
+
+
+
+
+
+ ApiDocNamespace
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a namespace integrated with its associated documentation
+
+
+
+
+
+
+
+
+
+
+ ApiDocs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+ ApiDocsSearchIndexEntry
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-codeformat.html b/reference/fsharp-formatting-codeformat-codeformat.html
new file mode 100644
index 000000000..2616c230a
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-codeformat.html
@@ -0,0 +1,656 @@
+
+
+
+
+
+ CodeFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormat Type
+
+
+
+
+
+
+ Exposes functionality of the F# code formatter with a nice interface
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ CodeFormat.FormatFsx(snippets)
+
+
+ Parameters:
+
+
+
+ snippets
+
+ :
+ Snippet seq
+
+
+
+
+
+ Returns:
+ FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formats the .fsx snippets as iPython notebook using the default settings.
+
+
+
+
+
+ -
+
+ snippets
+
+ :
+
Snippet seq
+
+
+
+
+ -
+
+ Returns:
+
+
FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormat.FormatHtml(snippets, prefix, ?openTag, ?closeTag, ?lineNumbers, ?openLinesTag, ?closeLinesTag, ?addErrors, ?tokenKindToCss)
+
+
+
+
+
+
+ Full Usage:
+ CodeFormat.FormatHtml(snippets, prefix, ?openTag, ?closeTag, ?lineNumbers, ?openLinesTag, ?closeLinesTag, ?addErrors, ?tokenKindToCss)
+
+
+ Parameters:
+
+
+
+ snippets
+
+ :
+ Snippet[]
+
+
+
+
+ prefix
+
+ :
+ string
+
+
+
+
+ ?openTag
+
+ :
+ string
+
+
+
+
+ ?closeTag
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?openLinesTag
+
+ :
+ string
+
+
+
+
+ ?closeLinesTag
+
+ :
+ string
+
+
+
+
+ ?addErrors
+
+ :
+ bool
+
+
+
+
+ ?tokenKindToCss
+
+ :
+ TokenKind -> string
+
+
+
+
+
+ Returns:
+ FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+ -
+
+ snippets
+
+ :
+
Snippet[]
+
+
+ -
+
+ prefix
+
+ :
+
string
+
+
+ -
+
+ ?openTag
+
+ :
+
string
+
+
+ -
+
+ ?closeTag
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?openLinesTag
+
+ :
+
string
+
+
+ -
+
+ ?closeLinesTag
+
+ :
+
string
+
+
+ -
+
+ ?addErrors
+
+ :
+
bool
+
+
+ -
+
+ ?tokenKindToCss
+
+ :
+
TokenKind -> string
+
+
+
+
+ -
+
+ Returns:
+
+
FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormat.FormatLatex(snippets, ?openTag, ?closeTag, ?lineNumbers)
+
+
+
+
+
+
+ Full Usage:
+ CodeFormat.FormatLatex(snippets, ?openTag, ?closeTag, ?lineNumbers)
+
+
+ Parameters:
+
+
+
+ snippets
+
+ :
+ Snippet[]
+
+
+
+
+ ?openTag
+
+ :
+ string
+
+
+
+
+ ?closeTag
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+
+ Returns:
+ FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Formats the .fsx snippets as LaTeX. The parameters specify prefix for LaTeX tags, whether lines should
+ be added to outputs.
+
+
+
+
+
+ -
+
+ snippets
+
+ :
+
Snippet[]
+
+
+ -
+
+ ?openTag
+
+ :
+
string
+
+
+ -
+
+ ?closeTag
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+
+
+ -
+
+ Returns:
+
+
FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-codeformatter.html b/reference/fsharp-formatting-codeformat-codeformatter.html
new file mode 100644
index 000000000..6ad2dea81
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-codeformatter.html
@@ -0,0 +1,915 @@
+
+
+
+
+
+ CodeFormatter (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormatter Module
+
+
+
+
+
+
+ Uses agent to handle formatting requests
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ParseAndCheckSource (file, source, options, defines, onError)
+
+
+
+
+
+
+ Full Usage:
+ ParseAndCheckSource (file, source, options, defines, onError)
+
+
+ Parameters:
+
+
+
+ file
+
+ :
+ string
+
+
+
+
+ source
+
+ :
+ string
+
+
+
+
+ options
+
+ :
+ string option
+
+
+
+
+ defines
+
+ :
+ string option
+
+
+
+
+ onError
+
+ :
+ string -> unit
+
+
+
+
+
+ Returns:
+ Snippet[] * SourceError[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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
+
+
+
+
+
+ -
+
+ file
+
+ :
+
string
+
+
+ -
+
+ source
+
+ :
+
string
+
+
+ -
+
+ options
+
+ :
+
string option
+
+
+ -
+
+ defines
+
+ :
+
string option
+
+
+ -
+
+ onError
+
+ :
+
string -> unit
+
+
+
+
+ -
+
+ Returns:
+
+
Snippet[] * SourceError[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ categoryToTokenKind _arg1
+
+
+ Parameters:
+
+
+
+ _arg1
+
+ :
+ SemanticClassificationType
+
+
+
+
+
+ Returns:
+ TokenKind option
+
+
+
+
+
+
+
+
+ -
+
+ _arg1
+
+ :
+
SemanticClassificationType
+
+
+
+
+ -
+
+ Returns:
+
+
TokenKind option
+
+
+
+
+
+
+
+
+
+
+
+
+ fsChecker
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
FSharpChecker
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ processDoubleBackticks body
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+ processSnippet checkResults categorizedRanges lines snippet
+
+
+
+
+
+
+ Full Usage:
+ processSnippet checkResults categorizedRanges lines snippet
+
+
+ Parameters:
+
+
+
+ checkResults
+
+ :
+ FSharpCheckFileResults
+
+
+
+
+ categorizedRanges
+
+ :
+ Map<int, 'a>
+
+
+
+
+ lines
+
+ :
+ string[]
+
+
+
+
+ snippet
+
+ :
+ Snippet
+
+
+
+
+
+ Returns:
+ Line list
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ checkResults
+
+ :
+
FSharpCheckFileResults
+
+
+ -
+
+ categorizedRanges
+
+ :
+
Map<int, 'a>
+
+
+ -
+
+ lines
+
+ :
+
string[]
+
+
+ -
+
+ snippet
+
+ :
+
Snippet
+
+
+
+
+ -
+
+ Returns:
+
+
Line list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ processSnippetLine checkResults semanticRanges lines (line, lineTokens)
+
+
+
+
+
+
+ Full Usage:
+ processSnippetLine checkResults semanticRanges lines (line, lineTokens)
+
+
+ Parameters:
+
+
+
+ checkResults
+
+ :
+ FSharpCheckFileResults
+
+
+
+
+ semanticRanges
+
+ :
+ SemanticClassificationItem[]
+
+
+
+
+ lines
+
+ :
+ string[]
+
+
+
+
+ line
+
+ :
+ int
+
+
+
+
+ lineTokens
+
+ :
+ SnippetLine
+
+
+
+
+
+ Returns:
+ Line
+
+
+
+
+
+
+
+
+ -
+
+ checkResults
+
+ :
+
FSharpCheckFileResults
+
+
+ -
+
+ semanticRanges
+
+ :
+
SemanticClassificationItem[]
+
+
+ -
+
+ lines
+
+ :
+
string[]
+
+
+ -
+
+ line
+
+ :
+
int
+
+
+ -
+
+ lineTokens
+
+ :
+
SnippetLine
+
+
+
+
+ -
+
+ Returns:
+
+
Line
+
+
+
+
+
+
+
+
+
+
+
+
+ processSourceCode (filePath, source, options, defines, onError)
+
+
+
+
+
+
+ Full Usage:
+ processSourceCode (filePath, source, options, defines, onError)
+
+
+ Parameters:
+
+
+
+ filePath
+
+ :
+ string
+
+
+
+
+ source
+
+ :
+ string
+
+
+
+
+ options
+
+ :
+ string option
+
+
+
+
+ defines
+
+ :
+ string option
+
+
+
+
+ onError
+
+ :
+ string -> unit
+
+
+
+
+
+ Returns:
+ Async<Snippet[] * SourceError[]>
+
+
+
+
+
+
+
+
+ -
+
+ filePath
+
+ :
+
string
+
+
+ -
+
+ source
+
+ :
+
string
+
+
+ -
+
+ options
+
+ :
+
string option
+
+
+ -
+
+ defines
+
+ :
+
string option
+
+
+ -
+
+ onError
+
+ :
+
string -> unit
+
+
+
+
+ -
+
+ Returns:
+
+
Async<Snippet[] * SourceError[]>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-errorkind.html b/reference/fsharp-formatting-codeformat-errorkind.html
new file mode 100644
index 000000000..f6b96f96b
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-errorkind.html
@@ -0,0 +1,306 @@
+
+
+
+
+
+ ErrorKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ErrorKind Type
+
+
+
+
+
+
+ Represents a kind of error reported from the F# compiler (warning or error)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-formattedcontent.html b/reference/fsharp-formatting-codeformat-formattedcontent.html
new file mode 100644
index 000000000..c0c6b4a81
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-formattedcontent.html
@@ -0,0 +1,445 @@
+
+
+
+
+
+ FormattedContent (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FormattedContent Type
+
+
+
+
+
+
+ Represents formatted snippets
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ FormattedContent(snippets, tips)
+
+
+ Parameters:
+
+
+
+ snippets
+
+ :
+ FormattedSnippet[]
+
+
+
+
+ tips
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ FormattedContent
+
+
+
+
+
+
+
+
+ -
+
+ snippets
+
+ :
+
FormattedSnippet[]
+
+
+ -
+
+ tips
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
FormattedContent
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Snippets
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
FormattedSnippet[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.ToolTip
+
+
+
+
+
+
+ Full Usage:
+ this.ToolTip
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-formattedsnippet.html b/reference/fsharp-formatting-codeformat-formattedsnippet.html
new file mode 100644
index 000000000..50a324548
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-formattedsnippet.html
@@ -0,0 +1,507 @@
+
+
+
+
+
+ FormattedSnippet (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FormattedSnippet Type
+
+
+
+
+
+
+ Represents an individual formatted snippet with title as key
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ FormattedSnippet(key, content)
+
+
+ Parameters:
+
+
+
+ key
+
+ :
+ string
+
+
+
+
+ content
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ FormattedSnippet
+
+
+
+
+
+
+
+
+ -
+
+ key
+
+ :
+
string
+
+
+ -
+
+ content
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
FormattedSnippet
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Content
+
+
+
+
+
+
+ Full Usage:
+ this.Content
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Key
+
+
+
+
+
+
+ Full Usage:
+ this.Key
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Title
+
+
+
+
+
+
+ Full Usage:
+ this.Title
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-line.html b/reference/fsharp-formatting-codeformat-line.html
new file mode 100644
index 000000000..626da11fe
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-line.html
@@ -0,0 +1,302 @@
+
+
+
+
+
+ Line (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Line Type
+
+
+
+
+
+
+ Represents a line of source code as a list of TokenSpan values. This is
+ a single case discriminated union with Line constructor.
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ Line(originalLine, tokenSpans)
+
+
+ Parameters:
+
+
+
+ originalLine
+
+ :
+ string
+
+
+
+
+ tokenSpans
+
+ :
+ TokenSpans
+
+
+
+
+
+
+
+
+
+
+ -
+
+ originalLine
+
+ :
+
string
+
+
+ -
+
+ tokenSpans
+
+ :
+
TokenSpans
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-snippet.html b/reference/fsharp-formatting-codeformat-snippet.html
new file mode 100644
index 000000000..4797b5b21
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-snippet.html
@@ -0,0 +1,301 @@
+
+
+
+
+
+ Snippet (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Snippet Type
+
+
+
+
+
+
+ An F# snippet consists of a snippet title and a list of lines
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
Line list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-sourceerror.html b/reference/fsharp-formatting-codeformat-sourceerror.html
new file mode 100644
index 000000000..15022d71f
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-sourceerror.html
@@ -0,0 +1,351 @@
+
+
+
+
+
+ SourceError (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SourceError Type
+
+
+
+
+
+
+ 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)
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ SourceError(start, finish, errorKind, message)
+
+
+ Parameters:
+
+
+
+ start
+
+ :
+ int * int
+
+
+
+
+ finish
+
+ :
+ int * int
+
+
+
+
+ errorKind
+
+ :
+ ErrorKind
+
+
+
+
+ message
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-tokenkind.html b/reference/fsharp-formatting-codeformat-tokenkind.html
new file mode 100644
index 000000000..6d438a085
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-tokenkind.html
@@ -0,0 +1,1054 @@
+
+
+
+
+
+ TokenKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TokenKind Type
+
+
+
+
+
+
+ Classifies tokens reported by the FCS
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Comment
+
+
+
+
+
+
+ Full Usage:
+ Comment
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Default
+
+
+
+
+
+
+ Full Usage:
+ Default
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Disposable
+
+
+
+
+
+
+ Full Usage:
+ Disposable
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Enumeration
+
+
+
+
+
+
+ Full Usage:
+ Enumeration
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Escaped
+
+
+
+
+
+
+ Full Usage:
+ Escaped
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Function
+
+
+
+
+
+
+ Full Usage:
+ Function
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Identifier
+
+
+
+
+
+
+ Full Usage:
+ Identifier
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Inactive
+
+
+
+
+
+
+ Full Usage:
+ Inactive
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Interface
+
+
+
+
+
+
+ Full Usage:
+ Interface
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keyword
+
+
+
+
+
+
+ Full Usage:
+ Keyword
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Module
+
+
+
+
+
+
+ Full Usage:
+ Module
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MutableVar
+
+
+
+
+
+
+ Full Usage:
+ MutableVar
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Number
+
+
+
+
+
+
+ Full Usage:
+ Number
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Operator
+
+
+
+
+
+
+ Full Usage:
+ Operator
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Pattern
+
+
+
+
+
+
+ Full Usage:
+ Pattern
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Preprocessor
+
+
+
+
+
+
+ Full Usage:
+ Preprocessor
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Printf
+
+
+
+
+
+
+ Full Usage:
+ Printf
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Property
+
+
+
+
+
+
+ Full Usage:
+ Property
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Punctuation
+
+
+
+
+
+
+ Full Usage:
+ Punctuation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ReferenceType
+
+
+
+
+
+
+ Full Usage:
+ ReferenceType
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ String
+
+
+
+
+
+
+ Full Usage:
+ String
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TypeArgument
+
+
+
+
+
+
+ Full Usage:
+ TypeArgument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ UnionCase
+
+
+
+
+
+
+ Full Usage:
+ UnionCase
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ValueType
+
+
+
+
+
+
+ Full Usage:
+ ValueType
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-tokenspan.html b/reference/fsharp-formatting-codeformat-tokenspan.html
new file mode 100644
index 000000000..e67ea6b47
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-tokenspan.html
@@ -0,0 +1,508 @@
+
+
+
+
+
+ TokenSpan (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TokenSpan Type
+
+
+
+
+
+
+ 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
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ Error(ErrorKind, string, TokenSpans)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ ErrorKind
+
+
+
+
+ Item2
+
+ :
+ string
+
+
+
+
+ Item3
+
+ :
+ TokenSpans
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
ErrorKind
+
+
+ -
+
+ Item2
+
+ :
+
string
+
+
+ -
+
+ Item3
+
+ :
+
TokenSpans
+
+
+
+
+
+
+
+
+
+
+
+
+ Omitted(string, string)
+
+
+
+
+
+
+ Full Usage:
+ Omitted(string, string)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+ Output string
+
+
+
+
+
+
+ Full Usage:
+ Output string
+
+
+ Parameters:
+
+
+
+ Item
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item
+
+ :
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ Token(TokenKind, string, ToolTipSpans option)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ TokenKind
+
+
+
+
+ Item2
+
+ :
+ string
+
+
+
+
+ Item3
+
+ :
+ ToolTipSpans option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
TokenKind
+
+
+ -
+
+ Item2
+
+ :
+
string
+
+
+ -
+
+ Item3
+
+ :
+
ToolTipSpans option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-tokenspans.html b/reference/fsharp-formatting-codeformat-tokenspans.html
new file mode 100644
index 000000000..ab3a4753c
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-tokenspans.html
@@ -0,0 +1,522 @@
+
+
+
+
+
+ TokenSpans (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TokenSpans Type
+
+
+
+
+
+
+ A type alias representing a list of TokenSpan values
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Head
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
TokenSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsEmpty
+
+
+
+
+
+
+ Full Usage:
+ this.IsEmpty
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this[index]
+
+
+
+
+
+
+ Full Usage:
+ this[index]
+
+
+ Parameters:
+
+
+
+ index
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ TokenSpan
+
+
+
+
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
TokenSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Length
+
+
+
+
+
+
+ Full Usage:
+ this.Length
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Tail
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
TokenSpan list
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ List.Empty
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
TokenSpan list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-tooltipspan.html b/reference/fsharp-formatting-codeformat-tooltipspan.html
new file mode 100644
index 000000000..4b257b566
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-tooltipspan.html
@@ -0,0 +1,366 @@
+
+
+
+
+
+ ToolTipSpan (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ToolTipSpan Type
+
+
+
+
+
+
+ A tool tip span can be emphasized text, plain text Literal or a line brak
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item
+
+ :
+
ToolTipSpans
+
+
+
+
+
+
+
+
+
+
+
+
+ HardLineBreak
+
+
+
+
+
+
+ Full Usage:
+ HardLineBreak
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literal string
+
+
+
+
+
+
+ Full Usage:
+ Literal string
+
+
+ Parameters:
+
+
+
+ Item
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item
+
+ :
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat-tooltipspans.html b/reference/fsharp-formatting-codeformat-tooltipspans.html
new file mode 100644
index 000000000..1c7214d5f
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat-tooltipspans.html
@@ -0,0 +1,522 @@
+
+
+
+
+
+ ToolTipSpans (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ToolTipSpans Type
+
+
+
+
+
+
+ A tool tip consists of a list of items reported from the compiler
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Head
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ToolTipSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsEmpty
+
+
+
+
+
+
+ Full Usage:
+ this.IsEmpty
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this[index]
+
+
+
+
+
+
+ Full Usage:
+ this[index]
+
+
+ Parameters:
+
+
+
+ index
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ ToolTipSpan
+
+
+
+
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
ToolTipSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Length
+
+
+
+
+
+
+ Full Usage:
+ this.Length
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Tail
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ToolTipSpan list
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ List.Empty
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ToolTipSpan list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-codeformat.html b/reference/fsharp-formatting-codeformat.html
new file mode 100644
index 000000000..610d102f1
--- /dev/null
+++ b/reference/fsharp-formatting-codeformat.html
@@ -0,0 +1,615 @@
+
+
+
+
+
+ FSharp.Formatting.CodeFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.CodeFormat Namespace
+
+
+
+ Functionality relating to formatting F# scripts and code snippets
+
+
+
+
+
+
+ Type/Module
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ CodeFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Exposes functionality of the F# code formatter with a nice interface
+
+
+
+
+
+
+
+
+
+
+ CodeFormatter
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ErrorKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a kind of error reported from the F# compiler (warning or error)
+
+
+
+
+
+
+
+
+
+
+ FormattedContent
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FormattedSnippet
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a line of source code as a list of TokenSpan values. This is
+ a single case discriminated union with Line constructor.
+
+
+
+
+
+
+
+
+
+
+ Snippet
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SourceError
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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)
+
+
+
+
+
+
+
+
+
+
+ TokenKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TokenSpan
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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
+
+
+
+
+
+
+
+
+
+
+ TokenSpans
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ToolTipSpan
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A tool tip span can be emphasized text, plain text Literal or a line brak
+
+
+
+
+
+
+
+
+
+
+ ToolTipSpans
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A tool tip consists of a list of items reported from the compiler
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-common-menu-menuitem.html b/reference/fsharp-formatting-common-menu-menuitem.html
new file mode 100644
index 000000000..fcdd4b43b
--- /dev/null
+++ b/reference/fsharp-formatting-common-menu-menuitem.html
@@ -0,0 +1,320 @@
+
+
+
+
+
+ MenuItem (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MenuItem Type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Content
+
+
+
+
+
+
+ Full Usage:
+ Content
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-common-menu.html b/reference/fsharp-formatting-common-menu.html
new file mode 100644
index 000000000..6337255ea
--- /dev/null
+++ b/reference/fsharp-formatting-common-menu.html
@@ -0,0 +1,484 @@
+
+
+
+
+
+ Menu (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Menu Module
+
+
+
+
+
+
+
+
+
+
+
+ Types
+
+
+
+
+
+ Type
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ MenuItem
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ createMenu input header items
+
+
+ Parameters:
+
+
+
+ input
+
+ :
+ string
+
+
+
+
+ header
+
+ :
+ string
+
+
+
+
+ items
+
+ :
+ MenuItem list
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ input
+
+ :
+
string
+
+
+ -
+
+ header
+
+ :
+
string
+
+
+ -
+
+ items
+
+ :
+
MenuItem list
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+ getLastWriteTimes input
+
+
+
+
+
+
+ Full Usage:
+ getLastWriteTimes input
+
+
+ Parameters:
+
+
+
+ input
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ DateTime list
+
+
+
+
+
+
+
+
+ -
+
+ input
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
DateTime list
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ isTemplatingAvailable input
+
+
+ Parameters:
+
+
+
+ input
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ input
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-common.html b/reference/fsharp-formatting-common.html
new file mode 100644
index 000000000..5b3f411f2
--- /dev/null
+++ b/reference/fsharp-formatting-common.html
@@ -0,0 +1,220 @@
+
+
+
+
+
+ FSharp.Formatting.Common
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-clikeformat.html b/reference/fsharp-formatting-csharpformat-clikeformat.html
new file mode 100644
index 000000000..ef22aa1a9
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-clikeformat.html
@@ -0,0 +1,405 @@
+
+
+
+
+
+ CLikeFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CLikeFormat Type
+
+
+
+
+
+
+ Provides a base class for formatting languages similar to C.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ CLikeFormat()
+
+
+
+
+
+
+ Full Usage:
+ CLikeFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match single line and multi-line
+ comments (// and /* */).
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string and character literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-codeformat.html b/reference/fsharp-formatting-csharpformat-codeformat.html
new file mode 100644
index 000000000..cd20949ee
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-codeformat.html
@@ -0,0 +1,735 @@
+
+
+
+
+
+ CodeFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormat Type
+
+
+
+
+
+
+ Provides a base class for formatting most programming languages.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormat()
+
+
+
+
+
+
+ Full Usage:
+ CodeFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CaseSensitive
+
+
+
+
+
+
+ Full Usage:
+ this.CaseSensitive
+
+
+
+ Returns:
+ bool
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Determines if the language is case sensitive.
+
+
+
+
+
+
+ A case-insensitive language formatter must override this
+ property to return false.
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must be overridden to provide a regular expression string
+ to match comments.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must be overridden to provide a list of keywords defined in
+ each language.
+
+
+
+
+
+
+ Keywords must be separated with spaces.
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.NumberRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.NumberRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Can be overridden to provide a list of tokes to be recognized as numbers.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Operators
+
+
+
+
+
+
+ Full Usage:
+ this.Operators
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must be overridden to provide a list of operators defined in
+ each language.
+
+
+
+
+
+
+ Operators must be separated with spaces.
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Can be overridden to provide a list of preprocessors defined in
+ each language.
+
+
+
+
+
+
+ Preprocessors must be separated with spaces.
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Must be overridden to provide a regular expression string
+ to match strings literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-cplusplusformat.html b/reference/fsharp-formatting-csharpformat-cplusplusformat.html
new file mode 100644
index 000000000..eeb2ef362
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-cplusplusformat.html
@@ -0,0 +1,404 @@
+
+
+
+
+
+ CPlusPlusFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CPlusPlusFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from C++ source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ CPlusPlusFormat()
+
+
+
+
+
+
+ Full Usage:
+ CPlusPlusFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of C++ keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of C++ preprocessors.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-csharpformat.html b/reference/fsharp-formatting-csharpformat-csharpformat.html
new file mode 100644
index 000000000..af68397da
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-csharpformat.html
@@ -0,0 +1,465 @@
+
+
+
+
+
+ CSharpFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CSharpFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from C# source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ CSharpFormat()
+
+
+
+
+
+
+ Full Usage:
+ CSharpFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of C# keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Operators
+
+
+
+
+
+
+ Full Usage:
+ this.Operators
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of C# preprocessors.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-fsharpformat.html b/reference/fsharp-formatting-csharpformat-fsharpformat.html
new file mode 100644
index 000000000..c9f663d58
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-fsharpformat.html
@@ -0,0 +1,588 @@
+
+
+
+
+
+ FSharpFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharpFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from F# source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ FSharpFormat()
+
+
+
+
+
+
+ Full Usage:
+ FSharpFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match single line and multi-line
+ comments (// and (* *)).
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of F# keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Operators
+
+
+
+
+
+
+ Full Usage:
+ this.Operators
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string and character literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-haskellformat.html b/reference/fsharp-formatting-csharpformat-haskellformat.html
new file mode 100644
index 000000000..450eca154
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-haskellformat.html
@@ -0,0 +1,526 @@
+
+
+
+
+
+ HaskellFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HaskellFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from MSH (code name Monad) source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ HaskellFormat()
+
+
+
+
+
+
+ Full Usage:
+ HaskellFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match single line comments (#).
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of MSH keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Use preprocessors property to hilight operators.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string and character literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-htmlformat.html b/reference/fsharp-formatting-csharpformat-htmlformat.html
new file mode 100644
index 000000000..0bec6aa86
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-htmlformat.html
@@ -0,0 +1,270 @@
+
+
+
+
+
+ HtmlFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HtmlFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from HTML/XML/ASPX source code.
+
+
+
+
+
+ This implementation assumes that code inside
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-javascriptformat.html b/reference/fsharp-formatting-csharpformat-javascriptformat.html
new file mode 100644
index 000000000..a7b89e053
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-javascriptformat.html
@@ -0,0 +1,465 @@
+
+
+
+
+
+ JavaScriptFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ JavaScriptFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from JavaSctript source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ JavaScriptFormat()
+
+
+
+
+
+
+ Full Usage:
+ JavaScriptFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of JavaScript keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Operators
+
+
+
+
+
+
+ Full Usage:
+ this.Operators
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Use the pre-processor color to mark directives that start with @.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-mshformat.html b/reference/fsharp-formatting-csharpformat-mshformat.html
new file mode 100644
index 000000000..179e7f4c9
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-mshformat.html
@@ -0,0 +1,526 @@
+
+
+
+
+
+ MshFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MshFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from MSH (code name Monad) source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ MshFormat()
+
+
+
+
+
+
+ Full Usage:
+ MshFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match single line comments (#).
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of MSH keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Use preprocessors property to hilight operators.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string and character literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-paketformat.html b/reference/fsharp-formatting-csharpformat-paketformat.html
new file mode 100644
index 000000000..ba21641ca
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-paketformat.html
@@ -0,0 +1,530 @@
+
+
+
+
+
+ PaketFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PaketFormat Type
+
+
+
+
+
+
+ Generates color-coded Paket source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ PaketFormat()
+
+
+
+
+
+
+ Full Usage:
+ PaketFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Paket Keywords
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.NumberRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.NumberRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Matches version numbers
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Operators
+
+
+
+
+
+
+ Full Usage:
+ this.Operators
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Paket operators
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-phpformat.html b/reference/fsharp-formatting-csharpformat-phpformat.html
new file mode 100644
index 000000000..47435f4b4
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-phpformat.html
@@ -0,0 +1,465 @@
+
+
+
+
+
+ PhpFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PhpFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from PHP source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ PhpFormat()
+
+
+
+
+
+
+ Full Usage:
+ PhpFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of PHP keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of PHP preprocessors.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string and character literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-sourceformat.html b/reference/fsharp-formatting-csharpformat-sourceformat.html
new file mode 100644
index 000000000..c5137945e
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-sourceformat.html
@@ -0,0 +1,992 @@
+
+
+
+
+
+ SourceFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SourceFormat Type
+
+
+
+
+
+
+ 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+.
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ SourceFormat()
+
+
+
+
+
+
+ Full Usage:
+ SourceFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Alternate
+
+
+
+
+
+
+ Full Usage:
+ this.Alternate
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Enables or disables alternating line background.
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CodeRegex
+
+
+
+
+
+
+ Full Usage:
+ this.CodeRegex
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The regular expression used to capture language tokens.
+
+
+
+
+
+
+
+
+
+
+
+
+ this.EmbedStyleSheet
+
+
+
+
+
+
+ Full Usage:
+ this.EmbedStyleSheet
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Enables or disables the embedded CSS style sheet.
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatCode
+
+
+
+
+
+
+ Full Usage:
+ this.FormatCode
+
+
+ Parameters:
+
+
+
+ source
+
+ :
+ Stream
+ -
+ Source code stream.
+
+
+
+
+
+ Returns:
+ string
+
+ A string containing the HTML formatted code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transforms a source code stream to HTML 4.01.
+
+
+
+
+
+ -
+
+ source
+
+ :
+
Stream
+
+ -
+
+ Source code stream.
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+ -
+
+ A string containing the HTML formatted code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatCode
+
+
+
+
+
+
+ Full Usage:
+ this.FormatCode
+
+
+ Parameters:
+
+
+
+ source
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+ A string containing the HTML formatted code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transforms a source code string to HTML 4.01.
+
+
+
+
+
+ -
+
+ source
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+ -
+
+ A string containing the HTML formatted code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormatSubCode
+
+
+
+
+
+
+ Full Usage:
+ this.FormatSubCode
+
+
+ Parameters:
+
+
+
+ source
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Allows formatting a part of the code in a different language,
+ for example a JavaScript block inside an HTML file.
+
+
+
+
+
+ -
+
+ source
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.LineNumbers
+
+
+
+
+
+
+ Full Usage:
+ this.LineNumbers
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Enables or disables line numbers in output.
+
+
+
+
+
+
+
+
+
+
+
+
+ this.TabSpaces
+
+
+
+
+
+
+ Full Usage:
+ this.TabSpaces
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets or sets the tabs width.
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ SourceFormat.EscapeHtml(str, tabSpaces)
+
+
+ Parameters:
+
+
+
+ str
+
+ :
+ string
+
+
+
+
+ tabSpaces
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ str
+
+ :
+
string
+
+
+ -
+
+ tabSpaces
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ SourceFormat.GetCssString()
+
+
+
+ Returns:
+ string
+
+ A string containing the CSS definitions.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets the CSS stylesheet as a string.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+ -
+
+ A string containing the CSS definitions.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html b/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html
new file mode 100644
index 000000000..0e85334fb
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-syntaxhighlighter.html
@@ -0,0 +1,458 @@
+
+
+
+
+
+ SyntaxHighlighter (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SyntaxHighlighter Type
+
+
+
+
+
+
+ Summary description for SyntaxHighlighter
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ SyntaxHighlighter()
+
+
+
+
+
+
+ Full Usage:
+ SyntaxHighlighter()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ SyntaxHighlighter.FormatCode(lang, code)
+
+
+ Parameters:
+
+
+
+ lang
+
+ :
+ string
+
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ bool * string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ lang
+
+ :
+
string
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
bool * string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ SyntaxHighlighter.FormatHtml(input)
+
+
+ Parameters:
+
+
+
+ input
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TBD
+
+
+
+
+
+ -
+
+ input
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-tsqlformat.html b/reference/fsharp-formatting-csharpformat-tsqlformat.html
new file mode 100644
index 000000000..d5330fb7f
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-tsqlformat.html
@@ -0,0 +1,588 @@
+
+
+
+
+
+ TsqlFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TsqlFormat Type
+
+
+
+
+
+
+ Generates color-coded T-SQL source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ TsqlFormat()
+
+
+
+
+
+
+ Full Usage:
+ TsqlFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CaseSensitive
+
+
+
+
+
+
+ Full Usage:
+ this.CaseSensitive
+
+
+
+ Returns:
+ bool
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns false, since T-SQL is not case sensitive.
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match single line
+ comments (--).
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of T-SQL keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Use the pre-processor color to mark keywords that start with @@.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-typescriptformat.html b/reference/fsharp-formatting-csharpformat-typescriptformat.html
new file mode 100644
index 000000000..9b90b5f04
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-typescriptformat.html
@@ -0,0 +1,343 @@
+
+
+
+
+
+ TypeScriptFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TypeScriptFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from TypeScript source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ TypeScriptFormat()
+
+
+
+
+
+
+ Full Usage:
+ TypeScriptFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of TypeScript keywords extends the ones from JavaScript.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat-visualbasicformat.html b/reference/fsharp-formatting-csharpformat-visualbasicformat.html
new file mode 100644
index 000000000..f04c17fd0
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat-visualbasicformat.html
@@ -0,0 +1,587 @@
+
+
+
+
+
+ VisualBasicFormat (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ VisualBasicFormat Type
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from Visual Basic source code.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ VisualBasicFormat()
+
+
+
+
+
+
+ Full Usage:
+ VisualBasicFormat()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.CaseSensitive
+
+
+
+
+
+
+ Full Usage:
+ this.CaseSensitive
+
+
+
+ Returns:
+ bool
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Determines if the language is case sensitive.
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.CommentRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.CommentRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match comments (' and REM).
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Keywords
+
+
+
+
+
+
+ Full Usage:
+ this.Keywords
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of VB keywords.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Preprocessors
+
+
+
+
+
+
+ Full Usage:
+ this.Preprocessors
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of VB preprocessors.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.StringRegEx
+
+
+
+
+
+
+ Full Usage:
+ this.StringRegEx
+
+
+
+ Returns:
+ string
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Regular expression string to match string and character literals.
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-csharpformat.html b/reference/fsharp-formatting-csharpformat.html
new file mode 100644
index 000000000..f5903f53b
--- /dev/null
+++ b/reference/fsharp-formatting-csharpformat.html
@@ -0,0 +1,706 @@
+
+
+
+
+
+ FSharp.Formatting.CSharpFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.CSharpFormat Namespace
+
+
+
+ Functionality for formatting code in various languages
+
+
+
+
+
+
+ Type
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ CLikeFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CodeFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provides a base class for formatting most programming languages.
+
+
+
+
+
+
+
+
+
+
+ CPlusPlusFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CSharpFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharpFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HaskellFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from MSH (code name Monad) source code.
+
+
+
+
+
+
+
+
+
+
+ HtmlFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ JavaScriptFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MshFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generates color-coded HTML 4.01 from MSH (code name Monad) source code.
+
+
+
+
+
+
+
+
+
+
+ PaketFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PhpFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SourceFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SyntaxHighlighter
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TsqlFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TypeScriptFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+ VisualBasicFormat
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html b/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html
new file mode 100644
index 000000000..75b887751
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-fsiembedkind.html
@@ -0,0 +1,454 @@
+
+
+
+
+
+ FsiEmbedKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiEmbedKind Type
+
+
+
+
+
+
+ Represents a kind of thing that can be embedded
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ConsoleOutput
+
+
+
+
+
+
+ Full Usage:
+ ConsoleOutput
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The stdout from this part of the execution (not including FSI output)
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiMergedOutput
+
+
+
+
+
+
+ Full Usage:
+ FsiMergedOutput
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The combined FSI output and console output
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiOutput
+
+
+
+
+
+
+ Full Usage:
+ FsiOutput
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The FSI output
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The 'it' value as raw text
+
+
+
+
+
+
+
+
+
+
+
+
+ ItValue
+
+
+
+
+
+
+ Full Usage:
+ ItValue
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The 'it' value
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A specific value
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html b/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html
new file mode 100644
index 000000000..098e4dfa3
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-fsievaluationfailedinfo.html
@@ -0,0 +1,428 @@
+
+
+
+
+
+ FsiEvaluationFailedInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluationFailedInfo Type
+
+
+
+
+
+
+ Record that is reported by the EvaluationFailed event when something
+ goes wrong during evalutaiton of an expression
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ AsExpression
+
+
+
+
+
+
+ Full Usage:
+ AsExpression
+
+
+
+ Field type:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ Exception
+
+
+
+
+
+
+ Full Usage:
+ Exception
+
+
+
+ Field type:
+ exn
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
exn
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+ StdErr
+
+
+
+
+
+
+ Full Usage:
+ StdErr
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html b/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html
new file mode 100644
index 000000000..27e0f304e
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-fsievaluationresult.html
@@ -0,0 +1,430 @@
+
+
+
+
+
+ FsiEvaluationResult (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluationResult Type
+
+
+
+
+
+
+ Represents the result of evaluating an F# snippet. This contains
+ the generated console output together with a result and its static type.
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ FsiMergedOutput
+
+
+
+
+
+
+ Full Usage:
+ FsiMergedOutput
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiOutput
+
+
+
+
+
+
+ Full Usage:
+ FsiOutput
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+ ItValue
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
(obj * Type) option
+
+
+
+
+
+
+
+
+
+
+
+
+ Output
+
+
+
+
+
+
+ Full Usage:
+ Output
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+ Result
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
(obj * Type) option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-fsievaluator.html b/reference/fsharp-formatting-literate-evaluation-fsievaluator.html
new file mode 100644
index 000000000..c737b27d3
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-fsievaluator.html
@@ -0,0 +1,523 @@
+
+
+
+
+
+ FsiEvaluator (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluator Type
+
+
+
+
+
+
+ A wrapper for F# interactive service that is used to evaluate inline snippets
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluator(?options, ?fsiObj, ?addHtmlPrinter, ?discardStdOut, ?disableFsiObj, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ FsiEvaluator(?options, ?fsiObj, ?addHtmlPrinter, ?discardStdOut, ?disableFsiObj, ?onError)
+
+
+ Parameters:
+
+
+
+ ?options
+
+ :
+ string[]
+
+
+
+
+ ?fsiObj
+
+ :
+ obj
+
+
+
+
+ ?addHtmlPrinter
+
+ :
+ bool
+
+
+
+
+ ?discardStdOut
+
+ :
+ bool
+
+
+
+
+ ?disableFsiObj
+
+ :
+ bool
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+
+ Returns:
+ FsiEvaluator
+
+
+
+
+
+
+
+
+ -
+
+ ?options
+
+ :
+
string[]
+
+
+ -
+
+ ?fsiObj
+
+ :
+
obj
+
+
+ -
+
+ ?addHtmlPrinter
+
+ :
+
bool
+
+
+ -
+
+ ?discardStdOut
+
+ :
+
bool
+
+
+ -
+
+ ?disableFsiObj
+
+ :
+
bool
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+
+
+
+ -
+
+ Returns:
+
+
FsiEvaluator
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.EvaluationFailed
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This event is fired whenever an evaluation of an expression fails
+
+
+
+
+
+ -
+
+ Returns:
+
+
IEvent<FsiEvaluationFailedInfo>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ this.RegisterTransformation
+
+
+ Parameters:
+
+
+
+ f
+
+ :
+ obj * Type * int -> MarkdownParagraph list option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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
+
+
+
+
+
+ -
+
+ f
+
+ :
+
obj * Type * int -> MarkdownParagraph list option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html b/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html
new file mode 100644
index 000000000..030488a15
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-fsievaluatorconfig.html
@@ -0,0 +1,347 @@
+
+
+
+
+
+ FsiEvaluatorConfig (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluatorConfig Type
+
+
+
+
+
+
+ Provides configuration options for the FsiEvaluator
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluatorConfig()
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
FsiEvaluatorConfig
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ FsiEvaluatorConfig.CreateNoOpFsiObject()
+
+
+
+ Returns:
+ obj
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+ -
+
+ Returns:
+
+
obj
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-ifsievaluationresult.html b/reference/fsharp-formatting-literate-evaluation-ifsievaluationresult.html
new file mode 100644
index 000000000..42a965484
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-ifsievaluationresult.html
@@ -0,0 +1,204 @@
+
+
+
+
+
+ IFsiEvaluationResult (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ IFsiEvaluationResult Type
+
+
+
+
+
+
+ An interface that represents FSI evaluation result
+ (we make this abstract so that evaluators can store other info)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html b/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html
new file mode 100644
index 000000000..56608dc50
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation-ifsievaluator.html
@@ -0,0 +1,468 @@
+
+
+
+
+
+ IFsiEvaluator (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ IFsiEvaluator Type
+
+
+
+
+
+
+ Represents an evaluator for F# snippets embedded in code
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Evaluate
+
+
+
+
+
+
+ Full Usage:
+ this.Evaluate
+
+
+ Parameters:
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+ asExpression
+
+ :
+ bool
+
+
+
+
+ file
+
+ :
+ string option
+
+
+
+
+
+ Returns:
+ IFsiEvaluationResult
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+ -
+
+ asExpression
+
+ :
+
bool
+
+
+ -
+
+ file
+
+ :
+
string option
+
+
+
+
+ -
+
+ Returns:
+
+
IFsiEvaluationResult
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Format
+
+
+
+
+
+
+ Full Usage:
+ this.Format
+
+
+ Parameters:
+
+
+
+ result
+
+ :
+ IFsiEvaluationResult
+
+
+
+
+ kind
+
+ :
+ FsiEmbedKind
+
+
+
+
+ executionCount
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ MarkdownParagraphs
+
+
+ Modifiers:
+ abstract
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Called to format some part of evaluation result generated by FSI
+
+
+
+
+
+ -
+
+ result
+
+ :
+
IFsiEvaluationResult
+
+
+ -
+
+ kind
+
+ :
+
FsiEmbedKind
+
+
+ -
+
+ executionCount
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-evaluation.html b/reference/fsharp-formatting-literate-evaluation.html
new file mode 100644
index 000000000..ee93118f8
--- /dev/null
+++ b/reference/fsharp-formatting-literate-evaluation.html
@@ -0,0 +1,421 @@
+
+
+
+
+
+ FSharp.Formatting.Literate.Evaluation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.Literate.Evaluation Namespace
+
+
+
+ Functionality to support literate evaluation for F# scripts
+
+
+
+
+
+
+ Type
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ FsiEmbedKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluationFailedInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Record that is reported by the EvaluationFailed event when something
+ goes wrong during evalutaiton of an expression
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluationResult
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents the result of evaluating an F# snippet. This contains
+ the generated console output together with a result and its static type.
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluator
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A wrapper for F# interactive service that is used to evaluate inline snippets
+
+
+
+
+
+
+
+
+
+
+ FsiEvaluatorConfig
+
+
+
+
+
+
+
+
+
+
+
+
+
+ IFsiEvaluationResult
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ An interface that represents FSI evaluation result
+ (we make this abstract so that evaluators can store other info)
+
+
+
+
+
+
+
+
+
+
+ IFsiEvaluator
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literate.html b/reference/fsharp-formatting-literate-literate.html
new file mode 100644
index 000000000..6ddc8795a
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literate.html
@@ -0,0 +1,2810 @@
+
+
+
+
+
+ Literate (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate Type
+
+
+
+
+
+
+ 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).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ConvertMarkdownFile(input, ?template, ?output, ?outputKind, ?prefix, ?fscOptions, ?lineNumbers, ?references, ?substitutions, ?generateAnchors, ?imageSaver, ?rootInputFolder, ?crefResolver, ?mdlinkResolver, ?onError, ?filesWithFrontMatter)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ConvertMarkdownFile(input, ?template, ?output, ?outputKind, ?prefix, ?fscOptions, ?lineNumbers, ?references, ?substitutions, ?generateAnchors, ?imageSaver, ?rootInputFolder, ?crefResolver, ?mdlinkResolver, ?onError, ?filesWithFrontMatter)
+
+
+ Parameters:
+
+
+
+ input
+
+ :
+ string
+
+
+
+
+ ?template
+
+ :
+ string
+
+
+
+
+ ?output
+
+ :
+ string
+
+
+
+
+ ?outputKind
+
+ :
+ OutputKind
+
+
+
+
+ ?prefix
+
+ :
+ string
+
+
+
+
+ ?fscOptions
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?references
+
+ :
+ bool
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?generateAnchors
+
+ :
+ bool
+
+
+
+
+ ?imageSaver
+
+ :
+ string -> string
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+ ?filesWithFrontMatter
+
+ :
+ FrontMatterFile[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ input
+
+ :
+
string
+
+
+ -
+
+ ?template
+
+ :
+
string
+
+
+ -
+
+ ?output
+
+ :
+
string
+
+
+ -
+
+ ?outputKind
+
+ :
+
OutputKind
+
+
+ -
+
+ ?prefix
+
+ :
+
string
+
+
+ -
+
+ ?fscOptions
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?references
+
+ :
+
bool
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ ?imageSaver
+
+ :
+
string -> string
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+
+ -
+
+ ?filesWithFrontMatter
+
+ :
+
FrontMatterFile[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ConvertScriptFile(input, ?template, ?output, ?outputKind, ?prefix, ?fscOptions, ?lineNumbers, ?references, ?fsiEvaluator, ?substitutions, ?generateAnchors, ?imageSaver, ?rootInputFolder, ?crefResolver, ?mdlinkResolver, ?onError, ?filesWithFrontMatter)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ConvertScriptFile(input, ?template, ?output, ?outputKind, ?prefix, ?fscOptions, ?lineNumbers, ?references, ?fsiEvaluator, ?substitutions, ?generateAnchors, ?imageSaver, ?rootInputFolder, ?crefResolver, ?mdlinkResolver, ?onError, ?filesWithFrontMatter)
+
+
+ Parameters:
+
+
+
+ input
+
+ :
+ string
+
+
+
+
+ ?template
+
+ :
+ string
+
+
+
+
+ ?output
+
+ :
+ string
+
+
+
+
+ ?outputKind
+
+ :
+ OutputKind
+
+
+
+
+ ?prefix
+
+ :
+ string
+
+
+
+
+ ?fscOptions
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?references
+
+ :
+ bool
+
+
+
+
+ ?fsiEvaluator
+
+ :
+ IFsiEvaluator
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?generateAnchors
+
+ :
+ bool
+
+
+
+
+ ?imageSaver
+
+ :
+ string -> string
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+ ?filesWithFrontMatter
+
+ :
+ FrontMatterFile[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ input
+
+ :
+
string
+
+
+ -
+
+ ?template
+
+ :
+
string
+
+
+ -
+
+ ?output
+
+ :
+
string
+
+
+ -
+
+ ?outputKind
+
+ :
+
OutputKind
+
+
+ -
+
+ ?prefix
+
+ :
+
string
+
+
+ -
+
+ ?fscOptions
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?references
+
+ :
+
bool
+
+
+ -
+
+ ?fsiEvaluator
+
+ :
+
IFsiEvaluator
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ ?imageSaver
+
+ :
+
string -> string
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+
+ -
+
+ ?filesWithFrontMatter
+
+ :
+
FrontMatterFile[]
+
+
+
+
+ Example
+
+
+
Literate.ConvertScriptFile("script.fsx", template)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ParseAndCheckScriptFile(path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ParseAndCheckScriptFile(path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+ Parameters:
+
+
+
+ path
+
+ :
+ string
+
+
+
+
+ ?fscOptions
+
+ :
+ string
+
+
+
+
+ ?definedSymbols
+
+ :
+ string list
+
+
+
+
+ ?references
+
+ :
+ bool
+
+
+
+
+ ?fsiEvaluator
+
+ :
+ IFsiEvaluator
+
+
+
+
+ ?parseOptions
+
+ :
+ MarkdownParseOptions
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+
+ Returns:
+ LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ path
+
+ :
+
string
+
+
+ -
+
+ ?fscOptions
+
+ :
+
string
+
+
+ -
+
+ ?definedSymbols
+
+ :
+
string list
+
+
+ -
+
+ ?references
+
+ :
+
bool
+
+
+ -
+
+ ?fsiEvaluator
+
+ :
+
IFsiEvaluator
+
+
+ -
+
+ ?parseOptions
+
+ :
+
MarkdownParseOptions
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ParseMarkdownFile(path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ParseMarkdownFile(path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+ Parameters:
+
+
+
+ path
+
+ :
+ string
+ -
+
+
+
+
+
+ ?fscOptions
+
+ :
+ string
+ -
+
+
+
+
+
+ ?definedSymbols
+
+ :
+ string list
+ -
+
+
+
+
+
+ ?references
+
+ :
+ bool
+ -
+
+
+
+
+
+ ?fsiEvaluator
+
+ :
+ IFsiEvaluator
+ -
+
+
+
+
+
+ ?parseOptions
+
+ :
+ MarkdownParseOptions
+ -
+ Defaults to MarkdownParseOptions.AllowYamlFrontMatter
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string
+ -
+
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+ -
+
+
+
+
+
+
+ Returns:
+ LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ path
+
+ :
+
string
+
+ -
+
+
+
+
+ -
+
+ ?fscOptions
+
+ :
+
string
+
+ -
+
+
+
+
+ -
+
+ ?definedSymbols
+
+ :
+
string list
+
+ -
+
+
+
+
+ -
+
+ ?references
+
+ :
+
bool
+
+ -
+
+
+
+
+ -
+
+ ?fsiEvaluator
+
+ :
+
IFsiEvaluator
+
+ -
+
+
+
+
+ -
+
+ ?parseOptions
+
+ :
+
MarkdownParseOptions
+
+ -
+
+ Defaults to MarkdownParseOptions.AllowYamlFrontMatter
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string
+
+ -
+
+
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+ -
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ParseMarkdownString(content, ?path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ParseMarkdownString(content, ?path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+ Parameters:
+
+
+
+ content
+
+ :
+ string
+ -
+
+
+
+
+
+ ?path
+
+ :
+ string
+ -
+ optional file path for debugging purposes
+
+
+
+
+ ?fscOptions
+
+ :
+ string
+ -
+
+
+
+
+
+ ?definedSymbols
+
+ :
+ string list
+ -
+
+
+
+
+
+ ?references
+
+ :
+ bool
+ -
+
+
+
+
+
+ ?fsiEvaluator
+
+ :
+ IFsiEvaluator
+ -
+
+
+
+
+
+ ?parseOptions
+
+ :
+ MarkdownParseOptions
+ -
+ Defaults to MarkdownParseOptions.AllowYamlFrontMatter
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string
+ -
+
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+ -
+
+
+
+
+
+
+ Returns:
+ LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ content
+
+ :
+
string
+
+ -
+
+
+
+
+ -
+
+ ?path
+
+ :
+
string
+
+ -
+
+ optional file path for debugging purposes
+
+
+ -
+
+ ?fscOptions
+
+ :
+
string
+
+ -
+
+
+
+
+ -
+
+ ?definedSymbols
+
+ :
+
string list
+
+ -
+
+
+
+
+ -
+
+ ?references
+
+ :
+
bool
+
+ -
+
+
+
+
+ -
+
+ ?fsiEvaluator
+
+ :
+
IFsiEvaluator
+
+ -
+
+
+
+
+ -
+
+ ?parseOptions
+
+ :
+
MarkdownParseOptions
+
+ -
+
+ Defaults to MarkdownParseOptions.AllowYamlFrontMatter
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string
+
+ -
+
+
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+ -
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ParseScriptString(content, ?path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ParseScriptString(content, ?path, ?fscOptions, ?definedSymbols, ?references, ?fsiEvaluator, ?parseOptions, ?rootInputFolder, ?onError)
+
+
+ Parameters:
+
+
+
+ content
+
+ :
+ string
+
+
+
+
+ ?path
+
+ :
+ string
+
+
+
+
+ ?fscOptions
+
+ :
+ string
+
+
+
+
+ ?definedSymbols
+
+ :
+ string list
+
+
+
+
+ ?references
+
+ :
+ bool
+
+
+
+
+ ?fsiEvaluator
+
+ :
+ IFsiEvaluator
+
+
+
+
+ ?parseOptions
+
+ :
+ MarkdownParseOptions
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string
+
+
+
+
+ ?onError
+
+ :
+ string -> unit
+
+
+
+
+
+ Returns:
+ LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ content
+
+ :
+
string
+
+
+ -
+
+ ?path
+
+ :
+
string
+
+
+ -
+
+ ?fscOptions
+
+ :
+
string
+
+
+ -
+
+ ?definedSymbols
+
+ :
+
string list
+
+
+ -
+
+ ?references
+
+ :
+
bool
+
+
+ -
+
+ ?fsiEvaluator
+
+ :
+
IFsiEvaluator
+
+
+ -
+
+ ?parseOptions
+
+ :
+
MarkdownParseOptions
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string
+
+
+ -
+
+ ?onError
+
+ :
+
string -> unit
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ToFsx(doc, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ToFsx(doc, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ LiterateDocument
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
LiterateDocument
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ToHtml(doc, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver, ?tokenKindToCss)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ToHtml(doc, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver, ?tokenKindToCss)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ LiterateDocument
+
+
+
+
+ ?prefix
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?generateAnchors
+
+ :
+ bool
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?tokenKindToCss
+
+ :
+ TokenKind -> string
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
LiterateDocument
+
+
+ -
+
+ ?prefix
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?tokenKindToCss
+
+ :
+
TokenKind -> string
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ToLatex(doc, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ToLatex(doc, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ LiterateDocument
+
+
+
+
+ ?prefix
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?generateAnchors
+
+ :
+ bool
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
LiterateDocument
+
+
+ -
+
+ ?prefix
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.ToPynb(doc, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Literate.ToPynb(doc, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ LiterateDocument
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
LiterateDocument
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.WriteHtml(doc, writer, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver, ?tokenKindToCss)
+
+
+
+
+
+
+ Full Usage:
+ Literate.WriteHtml(doc, writer, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver, ?tokenKindToCss)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ LiterateDocument
+
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ ?prefix
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?generateAnchors
+
+ :
+ bool
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?tokenKindToCss
+
+ :
+ TokenKind -> string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
LiterateDocument
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ ?prefix
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?tokenKindToCss
+
+ :
+
TokenKind -> string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Literate.WriteLatex(doc, writer, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Literate.WriteLatex(doc, writer, ?prefix, ?lineNumbers, ?generateAnchors, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ LiterateDocument
+
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ ?prefix
+
+ :
+ string
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+ ?generateAnchors
+
+ :
+ bool
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
LiterateDocument
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ ?prefix
+
+ :
+
string
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+ -
+
+ ?generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literatecodeoptions.html b/reference/fsharp-formatting-literate-literatecodeoptions.html
new file mode 100644
index 000000000..6498913d5
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literatecodeoptions.html
@@ -0,0 +1,458 @@
+
+
+
+
+
+ LiterateCodeOptions (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateCodeOptions Type
+
+
+
+
+
+
+ Additional properties of a literate code snippet, embedded in a
+ LiterateParagraph.LiterateCode. The properties specify how should
+ a snippet be evaluated and formatted.
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Evaluate
+
+
+
+
+
+
+ Full Usage:
+ Evaluate
+
+
+
+ Field type:
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Specifies whether the snippet is evalauted while processing
+ Use (*** do-not-eval ***) command to set this to false
+
+
+
+
+ -
+
+ Field type:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ExecutionCount
+
+
+
+
+
+
+ Full Usage:
+ ExecutionCount
+
+
+
+ Field type:
+ int option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Indiciates the execution sequence number of the cell if it has been evaluated
+
+
+
+
+
+ -
+
+ Field type:
+
+
int option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ OutputName
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Visibility
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Specifies the visibility of the snippet in the generated HTML
+
+
+
+
+
+ -
+
+ Field type:
+
+
LiterateCodeVisibility
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literatecodevisibility.html b/reference/fsharp-formatting-literate-literatecodevisibility.html
new file mode 100644
index 000000000..f975fb07d
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literatecodevisibility.html
@@ -0,0 +1,372 @@
+
+
+
+
+
+ LiterateCodeVisibility (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateCodeVisibility Type
+
+
+
+
+
+
+ Specifies visibility of a code snippet.
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ HiddenCode
+
+
+
+
+
+
+ Full Usage:
+ HiddenCode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Hidden snippet
+
+
+
+
+
+
+
+
+
+
+
+
+ NamedCode string
+
+
+
+
+
+
+ Full Usage:
+ NamedCode string
+
+
+ Parameters:
+
+
+
+ Item
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Named snippet with captured output
+
+
+
+
+
+ -
+
+ Item
+
+ :
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ VisibleCode
+
+
+
+
+
+
+ Full Usage:
+ VisibleCode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ordinary visible code
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literatedocument.html b/reference/fsharp-formatting-literate-literatedocument.html
new file mode 100644
index 000000000..ed7b8e933
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literatedocument.html
@@ -0,0 +1,1078 @@
+
+
+
+
+
+ LiterateDocument (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateDocument Type
+
+
+
+
+
+
+ Representation of a literate document - the representation of Paragraphs
+ uses an F# discriminated union type and so is best used from F#.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ LiterateDocument(paragraphs, formattedTips, links, source, sourceFile, rootInputFolder, diagnostics)
+
+
+
+
+
+
+ Full Usage:
+ LiterateDocument(paragraphs, formattedTips, links, source, sourceFile, rootInputFolder, diagnostics)
+
+
+ Parameters:
+
+
+
+ paragraphs
+
+ :
+ MarkdownParagraphs
+
+
+
+
+ formattedTips
+
+ :
+ string
+
+
+
+
+ links
+
+ :
+ IDictionary<string, (string * string option)>
+
+
+
+
+ source
+
+ :
+ LiterateSource
+
+
+
+
+ sourceFile
+
+ :
+ string
+
+
+
+
+ rootInputFolder
+
+ :
+ string option
+
+
+
+
+ diagnostics
+
+ :
+ SourceError[]
+
+
+
+
+
+ Returns:
+ LiterateDocument
+
+
+
+
+
+
+
+
+ -
+
+ paragraphs
+
+ :
+
MarkdownParagraphs
+
+
+ -
+
+ formattedTips
+
+ :
+
string
+
+
+ -
+
+ links
+
+ :
+
IDictionary<string, (string * string option)>
+
+
+ -
+
+ source
+
+ :
+
LiterateSource
+
+
+ -
+
+ sourceFile
+
+ :
+
string
+
+
+ -
+
+ rootInputFolder
+
+ :
+
string option
+
+
+ -
+
+ diagnostics
+
+ :
+
SourceError[]
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateDocument
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.DefinedLinks
+
+
+
+
+
+
+ Full Usage:
+ this.DefinedLinks
+
+
+
+ Returns:
+ IDictionary<string, (string * string option)>
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
IDictionary<string, (string * string option)>
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Diagnostics
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
SourceError[]
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.FormattedTips
+
+
+
+
+
+
+ Full Usage:
+ this.FormattedTips
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.MarkdownDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Paragraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.RootInputFolder
+
+
+
+
+
+
+ Full Usage:
+ this.RootInputFolder
+
+
+
+ Returns:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Source
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateSource
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.SourceFile
+
+
+
+
+
+
+ Full Usage:
+ this.SourceFile
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.With
+
+
+
+
+
+
+ Full Usage:
+ this.With
+
+
+ Parameters:
+
+
+
+ ?paragraphs
+
+ :
+ MarkdownParagraphs
+
+
+
+
+ ?formattedTips
+
+ :
+ string
+
+
+
+
+ ?definedLinks
+
+ :
+ IDictionary<string, (string * string option)>
+
+
+
+
+ ?source
+
+ :
+ LiterateSource
+
+
+
+
+ ?sourceFile
+
+ :
+ string
+
+
+
+
+ ?rootInputFolder
+
+ :
+ string option
+
+
+
+
+ ?diagnostics
+
+ :
+ SourceError[]
+
+
+
+
+
+ Returns:
+ LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ ?paragraphs
+
+ :
+
MarkdownParagraphs
+
+
+ -
+
+ ?formattedTips
+
+ :
+
string
+
+
+ -
+
+ ?definedLinks
+
+ :
+
IDictionary<string, (string * string option)>
+
+
+ -
+
+ ?source
+
+ :
+
LiterateSource
+
+
+ -
+
+ ?sourceFile
+
+ :
+
string
+
+
+ -
+
+ ?rootInputFolder
+
+ :
+
string option
+
+
+ -
+
+ ?diagnostics
+
+ :
+
SourceError[]
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literateparagraph.html b/reference/fsharp-formatting-literate-literateparagraph.html
new file mode 100644
index 000000000..0e8bca6be
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literateparagraph.html
@@ -0,0 +1,1116 @@
+
+
+
+
+
+ LiterateParagraph (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateParagraph Type
+
+
+
+
+
+
+ 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.)
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ CodeReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** include:foo ***) - Include formatted snippet from other part of the document here
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiMergedOutputReference(string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ FsiMergedOutputReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** include-fsi-merged-output ***) - Include output from previous snippet
+ (*** include-fsi-merged-output:foo ***) - Include output from a named snippet
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FsiOutputReference(string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ FsiOutputReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** include-fsi-output ***) - Include output from previous snippet
+ (*** include-fsi-output:foo ***) - Include output from a named snippet
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ItRawReference(string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ ItRawReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** 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)
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ItValueReference(string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ ItValueReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** include-it ***) - Include "it" value from the subsequent snippet here
+ (*** include-it:foo ***) - Include "it" value from a named snippet
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LanguageTaggedCode(string, string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ LanguageTaggedCode(string, string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ string
+
+
+
+
+ Item3
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ordinary formatted code snippet in non-F# language (tagged with language code)
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
string
+
+
+ -
+
+ Item3
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateCode(Line list, LiterateCodeOptions, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ LiterateCode(Line list, LiterateCodeOptions, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ Line list
+
+
+
+
+ Item2
+
+ :
+ LiterateCodeOptions
+
+
+
+
+ Item3
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Emebdded literate code snippet. Consists of source lines and options
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
Line list
+
+
+ -
+
+ Item2
+
+ :
+
LiterateCodeOptions
+
+
+ -
+
+ Item3
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ OutputReference(string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ OutputReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** include-fsi-output ***) - Include F# Interactive output from previous snippet
+ (*** include-fsi-output:foo ***) - Include F# Interactive from a named snippet
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ RawBlock(Line list, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ Line list
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
Line list
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ValueReference(string, LiterateParagraphOptions)
+
+
+
+
+
+
+ Full Usage:
+ ValueReference(string, LiterateParagraphOptions)
+
+
+ Parameters:
+
+
+
+ Item1
+
+ :
+ string
+
+
+
+
+ Item2
+
+ :
+ LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (*** include-value:foo ***) - Include the formatting of a specified value here
+
+
+
+
+
+ -
+
+ Item1
+
+ :
+
string
+
+
+ -
+
+ Item2
+
+ :
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.ParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateParagraphOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literateparagraphoptions.html b/reference/fsharp-formatting-literate-literateparagraphoptions.html
new file mode 100644
index 000000000..0c34272a8
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literateparagraphoptions.html
@@ -0,0 +1,292 @@
+
+
+
+
+
+ LiterateParagraphOptions (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateParagraphOptions Type
+
+
+
+
+
+
+ Specifies the options for a literate paragraph
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Condition
+
+
+
+
+
+
+ Full Usage:
+ Condition
+
+
+
+ Field type:
+ string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Specifies a conditional for inclusion of the snippet paragraph
+
+
+
+
+
+ -
+
+ Field type:
+
+
string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-literatesource.html b/reference/fsharp-formatting-literate-literatesource.html
new file mode 100644
index 000000000..53efc3344
--- /dev/null
+++ b/reference/fsharp-formatting-literate-literatesource.html
@@ -0,0 +1,362 @@
+
+
+
+
+
+ LiterateSource (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateSource Type
+
+
+
+
+
+
+ Represents the source of a literate document.
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Markdown string
+
+
+
+
+
+
+ Full Usage:
+ Markdown string
+
+
+ Parameters:
+
+
+
+ Item
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A markdown source
+
+
+
+
+
+ -
+
+ Item
+
+ :
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-markdownpatterns.html b/reference/fsharp-formatting-literate-markdownpatterns.html
new file mode 100644
index 000000000..6474ca169
--- /dev/null
+++ b/reference/fsharp-formatting-literate-markdownpatterns.html
@@ -0,0 +1,284 @@
+
+
+
+
+
+ MarkdownPatterns (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownPatterns Module
+
+
+
+
+
+
+ Provides active patterns for extracting LiterateParagraph values from
+ Markdown documents.
+
+
+
+
+
+
+
+
+ Active patterns
+
+
+
+
+
+ Active pattern
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ (|LiterateParagraph|_|) _arg1
+
+
+ Parameters:
+
+
+
+ _arg1
+
+ :
+ MarkdownParagraph
+
+
+
+
+
+ Returns:
+ LiterateParagraph option
+
+
+
+
+
+
+
+
+ -
+
+ _arg1
+
+ :
+
MarkdownParagraph
+
+
+
+
+ -
+
+ Returns:
+
+
LiterateParagraph option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate-outputkind.html b/reference/fsharp-formatting-literate-outputkind.html
new file mode 100644
index 000000000..2e11eb232
--- /dev/null
+++ b/reference/fsharp-formatting-literate-outputkind.html
@@ -0,0 +1,475 @@
+
+
+
+
+
+ OutputKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ OutputKind Type
+
+
+
+
+
+
+ Defines the possible output types from literate script (HTML, Latex, Pynb)
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Requests F# Script output
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Requests HTML output
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Requests LaTeX output
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown
+
+
+
+
+
+
+ Full Usage:
+ Markdown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Requests Markdown output
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Requests Notebook output
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Extension
+
+
+
+
+
+
+ Full Usage:
+ this.Extension
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-literate.html b/reference/fsharp-formatting-literate.html
new file mode 100644
index 000000000..8b8da3bd1
--- /dev/null
+++ b/reference/fsharp-formatting-literate.html
@@ -0,0 +1,491 @@
+
+
+
+
+
+ FSharp.Formatting.Literate
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.Literate Namespace
+
+
+
+ Functionality to support literate programming for F# scripts
+
+
+
+
+
+
+ Type/Module
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ Literate
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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).
+
+
+
+
+
+
+
+
+
+
+ LiterateCodeOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Additional properties of a literate code snippet, embedded in a
+ LiterateParagraph.LiterateCode. The properties specify how should
+ a snippet be evaluated and formatted.
+
+
+
+
+
+
+
+
+
+
+ LiterateCodeVisibility
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Representation of a literate document - the representation of Paragraphs
+ uses an F# discriminated union type and so is best used from F#.
+
+
+
+
+
+
+
+
+
+
+ LiterateParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ LiterateSource
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownPatterns
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provides active patterns for extracting LiterateParagraph values from
+ Markdown documents.
+
+
+
+
+
+
+
+
+
+
+ OutputKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines the possible output types from literate script (HTML, Latex, Pynb)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-dsl.html b/reference/fsharp-formatting-markdown-dsl.html
new file mode 100644
index 000000000..2e48be93a
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-dsl.html
@@ -0,0 +1,1138 @@
+
+
+
+
+
+ Dsl (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Dsl Module
+
+
+
+
+
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ !!value
+
+
+
+
+
+
+ Full Usage:
+ !!value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ ``#####`` value
+
+
+
+
+
+
+ Full Usage:
+ ``#####`` value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ ``####`` value
+
+
+
+
+
+
+ Full Usage:
+ ``####`` value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ ``###`` value
+
+
+
+
+
+
+ Full Usage:
+ ``###`` value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ ``##`` value
+
+
+
+
+
+
+ Full Usage:
+ ``##`` value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ ``#`` value
+
+
+
+
+
+
+ Full Usage:
+ ``#`` value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ img body link
+
+
+
+
+
+
+ Full Usage:
+ img body link
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ string
+
+
+
+
+ link
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
string
+
+
+ -
+
+ link
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ link content url
+
+
+
+
+
+
+ Full Usage:
+ link content url
+
+
+ Parameters:
+
+
+
+ content
+
+ :
+ MarkdownSpans
+
+
+
+
+ url
+
+ :
+ string
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ content
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ url
+
+ :
+
string
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ ol value
+
+
+
+
+
+
+ Full Usage:
+ ol value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownParagraphs list
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownParagraphs list
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ p value
+
+
+
+
+
+
+ Full Usage:
+ p value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ span value
+
+
+
+
+
+
+ Full Usage:
+ span value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ strong value
+
+
+
+
+
+
+ Full Usage:
+ strong value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ table headers alignments rows
+
+
+ Parameters:
+
+
+
+ headers
+
+ :
+ MarkdownParagraphs list
+
+
+
+
+ alignments
+
+ :
+ MarkdownColumnAlignment list
+
+
+
+
+ rows
+
+ :
+ MarkdownTableRow list
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ headers
+
+ :
+
MarkdownParagraphs list
+
+
+ -
+
+ alignments
+
+ :
+
MarkdownColumnAlignment list
+
+
+ -
+
+ rows
+
+ :
+
MarkdownTableRow list
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ ul value
+
+
+
+
+
+
+ Full Usage:
+ ul value
+
+
+ Parameters:
+
+
+
+ value
+
+ :
+ MarkdownParagraphs list
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ value
+
+ :
+
MarkdownParagraphs list
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-htmlformatting.html b/reference/fsharp-formatting-markdown-htmlformatting.html
new file mode 100644
index 000000000..44a71af9b
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-htmlformatting.html
@@ -0,0 +1,420 @@
+
+
+
+
+
+ HtmlFormatting (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HtmlFormatting Module
+
+
+
+
+
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ formatAsHtml writer generateAnchors wrap links substitutions newline crefResolver mdlinkResolver paragraphs
+
+
+
+
+
+
+ Full Usage:
+ formatAsHtml writer generateAnchors wrap links substitutions newline crefResolver mdlinkResolver paragraphs
+
+
+ Parameters:
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ generateAnchors
+
+ :
+ bool
+
+
+
+
+ wrap
+
+ :
+ bool
+
+
+
+
+ links
+
+ :
+ IDictionary<string, (string * string option)>
+
+
+
+
+ substitutions
+
+ :
+ Substitutions
+
+
+
+
+ newline
+
+ :
+ string
+
+
+
+
+ crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ paragraphs
+
+ :
+ MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ generateAnchors
+
+ :
+
bool
+
+
+ -
+
+ wrap
+
+ :
+
bool
+
+
+ -
+
+ links
+
+ :
+
IDictionary<string, (string * string option)>
+
+
+ -
+
+ substitutions
+
+ :
+
Substitutions
+
+
+ -
+
+ newline
+
+ :
+
string
+
+
+ -
+
+ crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ paragraphs
+
+ :
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdown.html b/reference/fsharp-formatting-markdown-markdown.html
new file mode 100644
index 000000000..6e83c70f2
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdown.html
@@ -0,0 +1,2035 @@
+
+
+
+
+
+ Markdown (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown Type
+
+
+
+
+
+
+ Static class that provides methods for formatting
+ and transforming Markdown documents.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ Markdown.Parse(text, ?newline, ?parseOptions)
+
+
+ Parameters:
+
+
+
+ text
+
+ :
+ string
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?parseOptions
+
+ :
+ MarkdownParseOptions
+
+
+
+
+
+ Returns:
+ MarkdownDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parse the specified text into a MarkdownDocument. Line breaks in the
+ inline HTML (etc.) will be stored using the specified string.
+
+
+
+
+
+ -
+
+ text
+
+ :
+
string
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?parseOptions
+
+ :
+
MarkdownParseOptions
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToFsx(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToFsx(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into Fsx and return the result as a string.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToHtml(markdownText, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToHtml(markdownText, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ markdownText
+
+ :
+ string
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform Markdown document into HTML format.
+ The result will be returned as a string.
+
+
+
+
+
+ -
+
+ markdownText
+
+ :
+
string
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToHtml(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToHtml(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into HTML
+ format and return the result as a string.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToLatex(markdownText, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver, ?lineNumbers)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToLatex(markdownText, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver, ?lineNumbers)
+
+
+ Parameters:
+
+
+
+ markdownText
+
+ :
+ string
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform Markdown text into LaTeX format. The result will be returned as a string.
+
+
+
+
+
+ -
+
+ markdownText
+
+ :
+
string
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToLatex(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver, ?lineNumbers)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToLatex(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver, ?lineNumbers)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into LaTeX
+ format and return the result as a string.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToMd(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToMd(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into Markdown and return the result as a string.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.ToPynb(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.ToPynb(doc, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+ Returns:
+ string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into Pynb and return the result as a string.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+ -
+
+ Returns:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.WriteHtml(markdownText, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.WriteHtml(markdownText, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ markdownText
+
+ :
+ string
+
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform Markdown text into HTML format. The result
+ will be written to the provided TextWriter.
+
+
+
+
+
+ -
+
+ markdownText
+
+ :
+
string
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.WriteHtml(doc, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.WriteHtml(doc, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into HTML
+ format and write the result to a given writer.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.WriteLatex(markdownText, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.WriteLatex(markdownText, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver)
+
+
+ Parameters:
+
+
+
+ markdownText
+
+ :
+ string
+
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform Markdown document into LaTeX format. The result
+ will be written to the provided TextWriter.
+
+
+
+
+
+ -
+
+ markdownText
+
+ :
+
string
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown.WriteLatex(doc, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver, ?lineNumbers)
+
+
+
+
+
+
+ Full Usage:
+ Markdown.WriteLatex(doc, writer, ?newline, ?substitutions, ?crefResolver, ?mdlinkResolver, ?lineNumbers)
+
+
+ Parameters:
+
+
+
+ doc
+
+ :
+ MarkdownDocument
+
+
+
+
+ writer
+
+ :
+ TextWriter
+
+
+
+
+ ?newline
+
+ :
+ string
+
+
+
+
+ ?substitutions
+
+ :
+ (ParamKey * string) list
+
+
+
+
+ ?crefResolver
+
+ :
+ string -> (string * string) option
+
+
+
+
+ ?mdlinkResolver
+
+ :
+ string -> string option
+
+
+
+
+ ?lineNumbers
+
+ :
+ bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform the provided MarkdownDocument into LaTeX
+ format and write the result to a given writer.
+
+
+
+
+
+ -
+
+ doc
+
+ :
+
MarkdownDocument
+
+
+ -
+
+ writer
+
+ :
+
TextWriter
+
+
+ -
+
+ ?newline
+
+ :
+
string
+
+
+ -
+
+ ?substitutions
+
+ :
+
(ParamKey * string) list
+
+
+ -
+
+ ?crefResolver
+
+ :
+
string -> (string * string) option
+
+
+ -
+
+ ?mdlinkResolver
+
+ :
+
string -> string option
+
+
+ -
+
+ ?lineNumbers
+
+ :
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdowncolumnalignment.html b/reference/fsharp-formatting-markdown-markdowncolumnalignment.html
new file mode 100644
index 000000000..6411ce3bf
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdowncolumnalignment.html
@@ -0,0 +1,374 @@
+
+
+
+
+
+ MarkdownColumnAlignment (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownColumnAlignment Type
+
+
+
+
+
+
+ Column in a table can be aligned to left, right, center or using the default alignment
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ AlignCenter
+
+
+
+
+
+
+ Full Usage:
+ AlignCenter
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ AlignDefault
+
+
+
+
+
+
+ Full Usage:
+ AlignDefault
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ AlignLeft
+
+
+
+
+
+
+ Full Usage:
+ AlignLeft
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ AlignRight
+
+
+
+
+
+
+ Full Usage:
+ AlignRight
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdowndocument.html b/reference/fsharp-formatting-markdown-markdowndocument.html
new file mode 100644
index 000000000..a708e1b3b
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdowndocument.html
@@ -0,0 +1,446 @@
+
+
+
+
+
+ MarkdownDocument (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownDocument Type
+
+
+
+
+
+
+ Representation of a Markdown document - the representation of Paragraphs
+ uses an F# discriminated union type and so is best used from F#.
+
+
+
+
+
+
+
+
+
+
+
+
+ Constructors
+
+
+
+
+
+ Constructor
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ MarkdownDocument(paragraphs, links)
+
+
+ Parameters:
+
+
+
+ paragraphs
+
+ :
+ MarkdownParagraphs
+
+
+
+
+ links
+
+ :
+ IDictionary<string, (string * string option)>
+
+
+
+
+
+ Returns:
+ MarkdownDocument
+
+
+
+
+
+
+
+
+ -
+
+ paragraphs
+
+ :
+
MarkdownParagraphs
+
+
+ -
+
+ links
+
+ :
+
IDictionary<string, (string * string option)>
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownDocument
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.DefinedLinks
+
+
+
+
+
+
+ Full Usage:
+ this.DefinedLinks
+
+
+
+ Returns:
+ IDictionary<string, (string * string option)>
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
IDictionary<string, (string * string option)>
+
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Paragraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownembedparagraphs.html b/reference/fsharp-formatting-markdown-markdownembedparagraphs.html
new file mode 100644
index 000000000..93267d21b
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownembedparagraphs.html
@@ -0,0 +1,273 @@
+
+
+
+
+
+ MarkdownEmbedParagraphs (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownEmbedParagraphs Type
+
+
+
+
+
+
+ Provides an extensibility point for adding custom kinds of paragraphs into a document
+ (MarkdownEmbedParagraphs values can be embedded using MarkdownParagraph.EmbedParagraphs)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Render
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownembedspans.html b/reference/fsharp-formatting-markdown-markdownembedspans.html
new file mode 100644
index 000000000..d541aa0b6
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownembedspans.html
@@ -0,0 +1,273 @@
+
+
+
+
+
+ MarkdownEmbedSpans (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownEmbedSpans Type
+
+
+
+
+
+
+ Provides an extensibility point for adding custom kinds of spans into a document
+ (MarkdownEmbedSpans values can be embedded using MarkdownSpan.EmbedSpans)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Render
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpans
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownlistkind.html b/reference/fsharp-formatting-markdown-markdownlistkind.html
new file mode 100644
index 000000000..857fce56f
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownlistkind.html
@@ -0,0 +1,306 @@
+
+
+
+
+
+ MarkdownListKind (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownListKind Type
+
+
+
+
+
+
+ A list kind can be Ordered or Unordered corresponding to <ol> and <ul> elements
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Ordered
+
+
+
+
+
+
+ Full Usage:
+ Ordered
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Unordered
+
+
+
+
+
+
+ Full Usage:
+ Unordered
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownparagraph.html b/reference/fsharp-formatting-markdown-markdownparagraph.html
new file mode 100644
index 000000000..02fe28be8
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownparagraph.html
@@ -0,0 +1,1472 @@
+
+
+
+
+
+ MarkdownParagraph (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownParagraph Type
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ CodeBlock(code, executionCount, fence, language, ignoredLine, range)
+
+
+
+
+
+
+ Full Usage:
+ CodeBlock(code, executionCount, fence, language, ignoredLine, range)
+
+
+ Parameters:
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+ executionCount
+
+ :
+ int option
+
+
+
+
+ fence
+
+ :
+ string option
+
+
+
+
+ language
+
+ :
+ string
+
+
+
+
+ ignoredLine
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A code block, whether fenced or via indentation
+
+
+
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+ -
+
+ executionCount
+
+ :
+
int option
+
+
+ -
+
+ fence
+
+ :
+
string option
+
+
+ -
+
+ language
+
+ :
+
string
+
+
+ -
+
+ ignoredLine
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ EmbedParagraphs(customParagraphs, range)
+
+
+ Parameters:
+
+
+
+ customParagraphs
+
+ :
+ MarkdownEmbedParagraphs
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A special addition for computing paragraphs
+
+
+
+
+
+ -
+
+ customParagraphs
+
+ :
+
MarkdownEmbedParagraphs
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ Heading(size, body, range)
+
+
+ Parameters:
+
+
+
+ size
+
+ :
+ int
+
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ size
+
+ :
+
int
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ HorizontalRule(character, range)
+
+
+ Parameters:
+
+
+
+ character
+
+ :
+ char
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Markdown Horizontal rule
+
+
+
+
+
+ -
+
+ character
+
+ :
+
char
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ InlineHtmlBlock(code, executionCount, range)
+
+
+ Parameters:
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+ executionCount
+
+ :
+ int option
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A HTML block
+
+
+
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+ -
+
+ executionCount
+
+ :
+
int option
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ LatexBlock(env, body, range)
+
+
+ Parameters:
+
+
+
+ env
+
+ :
+ string
+
+
+
+
+ body
+
+ :
+ string list
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Markdown Latex block
+
+
+
+
+
+ -
+
+ env
+
+ :
+
string
+
+
+ -
+
+ body
+
+ :
+
string list
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ ListBlock(kind, items, range)
+
+
+ Parameters:
+
+
+
+ kind
+
+ :
+ MarkdownListKind
+
+
+
+
+ items
+
+ :
+ MarkdownParagraphs list
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Markdown List block
+
+
+
+
+
+ -
+
+ kind
+
+ :
+
MarkdownListKind
+
+
+ -
+
+ items
+
+ :
+
MarkdownParagraphs list
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ OtherBlock(lines, range)
+
+
+ Parameters:
+
+
+
+ lines
+
+ :
+ (string * MarkdownRange) list
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents a block of markdown produced when parsing of code or tables or quoted blocks is suppressed
+
+
+
+
+
+ -
+
+ lines
+
+ :
+
(string * MarkdownRange) list
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ OutputBlock(output, kind, executionCount)
+
+
+ Parameters:
+
+
+
+ output
+
+ :
+ string
+
+
+
+
+ kind
+
+ :
+ string
+
+
+
+
+ executionCount
+
+ :
+ int option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A special addition for inserted outputs
+
+
+
+
+
+ -
+
+ output
+
+ :
+
string
+
+
+ -
+
+ kind
+
+ :
+
string
+
+
+ -
+
+ executionCount
+
+ :
+
int option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Paragraph(body, range)
+
+
+
+
+
+
+ Full Usage:
+ Paragraph(body, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ QuotedBlock(paragraphs, range)
+
+
+ Parameters:
+
+
+
+ paragraphs
+
+ :
+ MarkdownParagraphs
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Markdown Quote block
+
+
+
+
+
+ -
+
+ paragraphs
+
+ :
+
MarkdownParagraphs
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Span(body, range)
+
+
+
+
+
+
+ Full Usage:
+ Span(body, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Markdown Span block
+
+
+
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ TableBlock(headers, alignments, rows, range)
+
+
+ Parameters:
+
+
+
+ headers
+
+ :
+ MarkdownTableRow option
+
+
+
+
+ alignments
+
+ :
+ MarkdownColumnAlignment list
+
+
+
+
+ rows
+
+ :
+ MarkdownTableRow list
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A Markdown Table
+
+
+
+
+
+ -
+
+ headers
+
+ :
+
MarkdownTableRow option
+
+
+ -
+
+ alignments
+
+ :
+
MarkdownColumnAlignment list
+
+
+ -
+
+ rows
+
+ :
+
MarkdownTableRow list
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ YamlFrontmatter(yaml, range)
+
+
+ Parameters:
+
+
+
+ yaml
+
+ :
+ string list
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A special addition for YAML-style frontmatter
+
+
+
+
+
+ -
+
+ yaml
+
+ :
+
string list
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownparagraphs.html b/reference/fsharp-formatting-markdown-markdownparagraphs.html
new file mode 100644
index 000000000..06136eea9
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownparagraphs.html
@@ -0,0 +1,522 @@
+
+
+
+
+
+ MarkdownParagraphs (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownParagraphs Type
+
+
+
+
+
+
+ A type alias for a list of paragraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Head
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsEmpty
+
+
+
+
+
+
+ Full Usage:
+ this.IsEmpty
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this[index]
+
+
+
+
+
+
+ Full Usage:
+ this[index]
+
+
+ Parameters:
+
+
+
+ index
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Length
+
+
+
+
+
+
+ Full Usage:
+ this.Length
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Tail
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph list
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ List.Empty
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownparseoptions.html b/reference/fsharp-formatting-markdown-markdownparseoptions.html
new file mode 100644
index 000000000..b92bde03e
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownparseoptions.html
@@ -0,0 +1,408 @@
+
+
+
+
+
+ MarkdownParseOptions (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownParseOptions Type
+
+
+
+
+
+
+ Controls the parsing of markdown
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ AllowYamlFrontMatter
+
+
+
+
+
+
+ Full Usage:
+ AllowYamlFrontMatter
+
+
+
+ Field type:
+ MarkdownParseOptions
+
+
+ Modifiers:
+ static
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
MarkdownParseOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
MarkdownParseOptions
+
+
+
+
+
+
+
+
+
+
+
+
+ ParseCodeAsOther
+
+
+
+
+
+
+ Full Usage:
+ ParseCodeAsOther
+
+
+
+ Field type:
+ MarkdownParseOptions
+
+
+ Modifiers:
+ static
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
MarkdownParseOptions
+
+
+
+
+
+
+
+
+
+
+
+
+ ParseNonCodeAsOther
+
+
+
+
+
+
+ Full Usage:
+ ParseNonCodeAsOther
+
+
+
+ Field type:
+ MarkdownParseOptions
+
+
+ Modifiers:
+ static
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
MarkdownParseOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownpatterns-paragraphleafinfo.html b/reference/fsharp-formatting-markdown-markdownpatterns-paragraphleafinfo.html
new file mode 100644
index 000000000..71f12a98b
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownpatterns-paragraphleafinfo.html
@@ -0,0 +1,209 @@
+
+
+
+
+
+ ParagraphLeafInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownpatterns-paragraphnestedinfo.html b/reference/fsharp-formatting-markdown-markdownpatterns-paragraphnestedinfo.html
new file mode 100644
index 000000000..9c6ef8c32
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownpatterns-paragraphnestedinfo.html
@@ -0,0 +1,209 @@
+
+
+
+
+
+ ParagraphNestedInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParagraphNestedInfo Type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownpatterns-paragraphspansinfo.html b/reference/fsharp-formatting-markdown-markdownpatterns-paragraphspansinfo.html
new file mode 100644
index 000000000..a8cc352ab
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownpatterns-paragraphspansinfo.html
@@ -0,0 +1,209 @@
+
+
+
+
+
+ ParagraphSpansInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownpatterns-spanleafinfo.html b/reference/fsharp-formatting-markdown-markdownpatterns-spanleafinfo.html
new file mode 100644
index 000000000..88f03b4f0
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownpatterns-spanleafinfo.html
@@ -0,0 +1,209 @@
+
+
+
+
+
+ SpanLeafInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownpatterns-spannodeinfo.html b/reference/fsharp-formatting-markdown-markdownpatterns-spannodeinfo.html
new file mode 100644
index 000000000..9ba1901e2
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownpatterns-spannodeinfo.html
@@ -0,0 +1,209 @@
+
+
+
+
+
+ SpanNodeInfo (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownpatterns.html b/reference/fsharp-formatting-markdown-markdownpatterns.html
new file mode 100644
index 000000000..b4ce79acf
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownpatterns.html
@@ -0,0 +1,885 @@
+
+
+
+
+
+ MarkdownPatterns (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownPatterns Module
+
+
+
+
+
+
+ This module provides an easy way of processing Markdown documents.
+ It lets you decompose documents into leafs and nodes with nested paragraphs.
+
+
+
+
+
+
+ Types
+
+
+
+
+
+ Type
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ ParagraphLeafInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParagraphNestedInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParagraphSpansInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SpanLeafInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+ SpanNodeInfo
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ParagraphLeaf arg1
+
+
+
+
+
+
+ Full Usage:
+ ParagraphLeaf arg1
+
+
+ Parameters:
+
+
+
+ arg0
+
+ :
+ ParagraphLeafInfo
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ arg0
+
+ :
+
ParagraphLeafInfo
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ ParagraphNested (arg1, pars)
+
+
+ Parameters:
+
+
+
+ arg0
+
+ :
+ ParagraphNestedInfo
+
+
+
+
+ pars
+
+ :
+ MarkdownParagraphs list
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ arg0
+
+ :
+
ParagraphNestedInfo
+
+
+ -
+
+ pars
+
+ :
+
MarkdownParagraphs list
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ ParagraphSpans (arg1, spans)
+
+
+ Parameters:
+
+
+
+ arg0
+
+ :
+ ParagraphSpansInfo
+
+
+
+
+ spans
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+ -
+
+ arg0
+
+ :
+
ParagraphSpansInfo
+
+
+ -
+
+ spans
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+ SpanLeaf arg1
+
+
+
+
+
+
+ Full Usage:
+ SpanLeaf arg1
+
+
+ Parameters:
+
+
+
+ arg0
+
+ :
+ SpanLeafInfo
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ arg0
+
+ :
+
SpanLeafInfo
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ SpanNode (arg1, spans)
+
+
+
+
+
+
+ Full Usage:
+ SpanNode (arg1, spans)
+
+
+ Parameters:
+
+
+
+ arg0
+
+ :
+ SpanNodeInfo
+
+
+
+
+ spans
+
+ :
+ MarkdownSpans
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ arg0
+
+ :
+
SpanNodeInfo
+
+
+ -
+
+ spans
+
+ :
+
MarkdownSpans
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+ Active patterns
+
+
+
+
+
+ Active pattern
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ (|ParagraphLeaf|ParagraphNested|ParagraphSpans|) par
+
+
+
+
+
+
+ Full Usage:
+ (|ParagraphLeaf|ParagraphNested|ParagraphSpans|) par
+
+
+ Parameters:
+
+
+
+ par
+
+ :
+ MarkdownParagraph
+
+
+
+
+
+ Returns:
+ Choice<ParagraphLeafInfo, (ParagraphNestedInfo * MarkdownParagraphs list), (ParagraphSpansInfo * MarkdownSpans)>
+
+
+
+
+
+
+
+
+ -
+
+ par
+
+ :
+
MarkdownParagraph
+
+
+
+
+ -
+
+ Returns:
+
+
Choice<ParagraphLeafInfo, (ParagraphNestedInfo * MarkdownParagraphs list), (ParagraphSpansInfo * MarkdownSpans)>
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ (|SpanLeaf|SpanNode|) span
+
+
+ Parameters:
+
+
+
+ span
+
+ :
+ MarkdownSpan
+
+
+
+
+
+ Returns:
+ Choice<SpanLeafInfo, (SpanNodeInfo * MarkdownSpans)>
+
+
+
+
+
+
+
+
+ -
+
+ span
+
+ :
+
MarkdownSpan
+
+
+
+
+ -
+
+ Returns:
+
+
Choice<SpanLeafInfo, (SpanNodeInfo * MarkdownSpans)>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownrange.html b/reference/fsharp-formatting-markdown-markdownrange.html
new file mode 100644
index 000000000..e0d9662e3
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownrange.html
@@ -0,0 +1,395 @@
+
+
+
+
+
+ MarkdownRange (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownRange Type
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ EndColumn
+
+
+
+
+
+
+ Full Usage:
+ EndColumn
+
+
+
+ Field type:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ EndLine
+
+
+
+
+
+
+ Full Usage:
+ EndLine
+
+
+
+ Field type:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ StartColumn
+
+
+
+
+
+
+ Full Usage:
+ StartColumn
+
+
+
+ Field type:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ StartLine
+
+
+
+
+
+
+ Full Usage:
+ StartLine
+
+
+
+ Field type:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownrangemodule.html b/reference/fsharp-formatting-markdown-markdownrangemodule.html
new file mode 100644
index 000000000..ee9394ce7
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownrangemodule.html
@@ -0,0 +1,320 @@
+
+
+
+
+
+ MarkdownRange (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownRange Module
+
+
+
+
+
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ mergeRanges ranges
+
+
+
+
+
+
+ Full Usage:
+ mergeRanges ranges
+
+
+ Parameters:
+
+
+
+ ranges
+
+ :
+ MarkdownRange list
+
+
+
+
+
+ Returns:
+ MarkdownRange
+
+
+
+
+
+
+
+
+ -
+
+ ranges
+
+ :
+
MarkdownRange list
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownRange
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownRange
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownspan.html b/reference/fsharp-formatting-markdown-markdownspan.html
new file mode 100644
index 000000000..d42ebba71
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownspan.html
@@ -0,0 +1,1164 @@
+
+
+
+
+
+ MarkdownSpan (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownSpan Type
+
+
+
+
+
+
+ Represents inline formatting inside a paragraph. This can be literal (with text), various
+ formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc.
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ AnchorLink(link, range)
+
+
+
+
+
+
+ Full Usage:
+ AnchorLink(link, range)
+
+
+ Parameters:
+
+
+
+ link
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ link
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ DirectImage(body, link, title, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ string
+
+
+
+
+ link
+
+ :
+ string
+
+
+
+
+ title
+
+ :
+ string option
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
string
+
+
+ -
+
+ link
+
+ :
+
string
+
+
+ -
+
+ title
+
+ :
+
string option
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ DirectLink(body, link, title, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ link
+
+ :
+ string
+
+
+
+
+ title
+
+ :
+ string option
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ link
+
+ :
+
string
+
+
+ -
+
+ title
+
+ :
+
string option
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ EmbedSpans(customSpans, range)
+
+
+ Parameters:
+
+
+
+ customSpans
+
+ :
+ MarkdownEmbedSpans
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ customSpans
+
+ :
+
MarkdownEmbedSpans
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+ Emphasis(body, range)
+
+
+
+
+
+
+ Full Usage:
+ Emphasis(body, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+ HardLineBreak range
+
+
+
+
+
+
+ Full Usage:
+ HardLineBreak range
+
+
+ Parameters:
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ IndirectImage(body, link, key, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ string
+
+
+
+
+ link
+
+ :
+ string
+
+
+
+
+ key
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
string
+
+
+ -
+
+ link
+
+ :
+
string
+
+
+ -
+
+ key
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ IndirectLink(body, original, key, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ original
+
+ :
+ string
+
+
+
+
+ key
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ original
+
+ :
+
string
+
+
+ -
+
+ key
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+ InlineCode(code, range)
+
+
+
+
+
+
+ Full Usage:
+ InlineCode(code, range)
+
+
+ Parameters:
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ LatexDisplayMath(code, range)
+
+
+ Parameters:
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Full Usage:
+ LatexInlineMath(code, range)
+
+
+ Parameters:
+
+
+
+ code
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ code
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+ Literal(text, range)
+
+
+
+
+
+
+ Full Usage:
+ Literal(text, range)
+
+
+ Parameters:
+
+
+
+ text
+
+ :
+ string
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ text
+
+ :
+
string
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+ Strong(body, range)
+
+
+
+
+
+
+ Full Usage:
+ Strong(body, range)
+
+
+ Parameters:
+
+
+
+ body
+
+ :
+ MarkdownSpans
+
+
+
+
+ range
+
+ :
+ MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+ -
+
+ body
+
+ :
+
MarkdownSpans
+
+
+ -
+
+ range
+
+ :
+
MarkdownRange option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdownspans.html b/reference/fsharp-formatting-markdown-markdownspans.html
new file mode 100644
index 000000000..3dbc77620
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdownspans.html
@@ -0,0 +1,522 @@
+
+
+
+
+
+ MarkdownSpans (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownSpans Type
+
+
+
+
+
+
+ A type alias for a list of MarkdownSpan values
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Head
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsEmpty
+
+
+
+
+
+
+ Full Usage:
+ this.IsEmpty
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this[index]
+
+
+
+
+
+
+ Full Usage:
+ this[index]
+
+
+ Parameters:
+
+
+
+ index
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ MarkdownSpan
+
+
+
+
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Length
+
+
+
+
+
+
+ Full Usage:
+ this.Length
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Tail
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan list
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ List.Empty
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownSpan list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown-markdowntablerow.html b/reference/fsharp-formatting-markdown-markdowntablerow.html
new file mode 100644
index 000000000..48856d030
--- /dev/null
+++ b/reference/fsharp-formatting-markdown-markdowntablerow.html
@@ -0,0 +1,522 @@
+
+
+
+
+
+ MarkdownTableRow (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownTableRow Type
+
+
+
+
+
+
+ A type alias representing table row as a list of paragraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Head
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsEmpty
+
+
+
+
+
+
+ Full Usage:
+ this.IsEmpty
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this[index]
+
+
+
+
+
+
+ Full Usage:
+ this[index]
+
+
+ Parameters:
+
+
+
+ index
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ MarkdownParagraphs
+
+
+
+
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Length
+
+
+
+
+
+
+ Full Usage:
+ this.Length
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Tail
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs list
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ List.Empty
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
MarkdownParagraphs list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-markdown.html b/reference/fsharp-formatting-markdown.html
new file mode 100644
index 000000000..b56d16c47
--- /dev/null
+++ b/reference/fsharp-formatting-markdown.html
@@ -0,0 +1,738 @@
+
+
+
+
+
+ FSharp.Formatting.Markdown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.Markdown Namespace
+
+
+
+ Functionality for processing markdown documents, converting to HTML, LaTeX, ipynb and scripts
+
+
+
+
+
+
+ Type/Module
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ HtmlFormatting
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Markdown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static class that provides methods for formatting
+ and transforming Markdown documents.
+
+
+
+
+
+
+
+
+
+
+ MarkdownColumnAlignment
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Column in a table can be aligned to left, right, center or using the default alignment
+
+
+
+
+
+
+
+
+
+
+ MarkdownDocument
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Representation of a Markdown document - the representation of Paragraphs
+ uses an F# discriminated union type and so is best used from F#.
+
+
+
+
+
+
+
+
+
+
+ MarkdownEmbedParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provides an extensibility point for adding custom kinds of paragraphs into a document
+ (MarkdownEmbedParagraphs values can be embedded using MarkdownParagraph.EmbedParagraphs)
+
+
+
+
+
+
+
+
+
+
+ MarkdownEmbedSpans
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provides an extensibility point for adding custom kinds of spans into a document
+ (MarkdownEmbedSpans values can be embedded using MarkdownSpan.EmbedSpans)
+
+
+
+
+
+
+
+
+
+
+ MarkdownListKind
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A list kind can be Ordered or Unordered corresponding to <ol> and <ul> elements
+
+
+
+
+
+
+
+
+
+
+ MarkdownParagraph
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+ MarkdownParagraphs
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownParseOptions
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownPatterns
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This module provides an easy way of processing Markdown documents.
+ It lets you decompose documents into leafs and nodes with nested paragraphs.
+
+
+
+
+
+
+
+
+
+
+ MarkdownRange (Module)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownRange (Type)
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownSpan
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Represents inline formatting inside a paragraph. This can be literal (with text), various
+ formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc.
+
+
+
+
+
+
+
+
+
+
+ MarkdownSpans
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MarkdownTableRow
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-templating-frontmatterfile.html b/reference/fsharp-formatting-templating-frontmatterfile.html
new file mode 100644
index 000000000..289f4dd29
--- /dev/null
+++ b/reference/fsharp-formatting-templating-frontmatterfile.html
@@ -0,0 +1,513 @@
+
+
+
+
+
+ FrontMatterFile (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FrontMatterFile Type
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+ Record fields
+
+
+
+
+
+ Record Field
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ Category
+
+
+
+
+
+
+ Full Usage:
+ Category
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+ CategoryIndex
+
+
+
+
+
+
+ Full Usage:
+ CategoryIndex
+
+
+
+ Field type:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ FileName
+
+
+
+
+
+
+ Full Usage:
+ FileName
+
+
+
+ Field type:
+ string
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
string
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Field type:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ FrontMatterFile.ParseFromLines(fileName) (lines)
+
+
+
+
+
+
+ Full Usage:
+ FrontMatterFile.ParseFromLines(fileName) (lines)
+
+
+ Parameters:
+
+
+
+ fileName
+
+ :
+ string
+
+
+
+
+ lines
+
+ :
+ string seq
+
+
+
+
+
+ Returns:
+ FrontMatterFile option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parses the category, categoryindex and index from the frontmatter lines
+
+
+
+
+
+ -
+
+ fileName
+
+ :
+
string
+
+
+ -
+
+ lines
+
+ :
+
string seq
+
+
+
+
+ -
+
+ Returns:
+
+
FrontMatterFile option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-templating-paramkey.html b/reference/fsharp-formatting-templating-paramkey.html
new file mode 100644
index 000000000..062f73203
--- /dev/null
+++ b/reference/fsharp-formatting-templating-paramkey.html
@@ -0,0 +1,288 @@
+
+
+
+
+
+ ParamKey (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParamKey Type
+
+
+
+
+
+
+ A parameter key
+
+
+
+
+
+
+
+
+
+ Union cases
+
+
+
+
+
+ Union case
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ ParamKey string
+
+
+
+
+
+
+ Full Usage:
+ ParamKey string
+
+
+ Parameters:
+
+
+
+ Item
+
+ :
+ string
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Item
+
+ :
+
string
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-templating-paramkeys.html b/reference/fsharp-formatting-templating-paramkeys.html
new file mode 100644
index 000000000..d587602c7
--- /dev/null
+++ b/reference/fsharp-formatting-templating-paramkeys.html
@@ -0,0 +1,2516 @@
+
+
+
+
+
+ ParamKeys (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParamKeys Module
+
+
+
+
+
+
+ Defines the parameter keys known to FSharp.Formatting processing code
+
+
+
+
+
+
+ Functions and values
+
+
+
+
+
+ Function or value
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParamKeys.root
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-templating-substitutions.html b/reference/fsharp-formatting-templating-substitutions.html
new file mode 100644
index 000000000..317357e77
--- /dev/null
+++ b/reference/fsharp-formatting-templating-substitutions.html
@@ -0,0 +1,522 @@
+
+
+
+
+
+ Substitutions (FSharp.Formatting)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Substitutions Type
+
+
+
+
+
+
+ A list of parameters for substituting in templates, indexed by parameter keys
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Instance members
+
+
+
+
+
+ Instance member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ this.Head
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
ParamKey * string
+
+
+
+
+
+
+
+
+
+
+
+
+ this.IsEmpty
+
+
+
+
+
+
+ Full Usage:
+ this.IsEmpty
+
+
+
+ Returns:
+ bool
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+
+
+
+
+
+
+
+
+
+
+
+ this[index]
+
+
+
+
+
+
+ Full Usage:
+ this[index]
+
+
+ Parameters:
+
+
+
+ index
+
+ :
+ int
+
+
+
+
+
+ Returns:
+ ParamKey * string
+
+
+
+
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+
+
+
+ -
+
+ Returns:
+
+
ParamKey * string
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Length
+
+
+
+
+
+
+ Full Usage:
+ this.Length
+
+
+
+ Returns:
+ int
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+
+
+
+
+
+
+
+
+
+
+
+ this.Tail
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(ParamKey * string) list
+
+
+
+
+
+
+
+
+
+
+ Static members
+
+
+
+
+
+ Static member
+
+
+ Description
+
+
+
+
+
+
+
+
+
+
+
+ List.Empty
+
+
+
+
+
+
+
+
+
+
+
+ -
+
+ Returns:
+
+
(ParamKey * string) list
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/fsharp-formatting-templating.html b/reference/fsharp-formatting-templating.html
new file mode 100644
index 000000000..c509a2b34
--- /dev/null
+++ b/reference/fsharp-formatting-templating.html
@@ -0,0 +1,323 @@
+
+
+
+
+
+ FSharp.Formatting.Templating
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FSharp.Formatting.Templating Namespace
+
+
+
+ Functionality relating to templating (mostly internal)
+
+
+
+
+
+
+ Type/Module
+
+
+ Description
+
+
+
+
+
+
+
+
+
+ FrontMatterFile
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+ ParamKey
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ParamKeys
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines the parameter keys known to FSharp.Formatting processing code
+
+
+
+
+
+
+
+
+
+
+ Substitutions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A list of parameters for substituting in templates, indexed by parameter keys
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/reference/index.html b/reference/index.html
new file mode 100644
index 000000000..e6c724443
--- /dev/null
+++ b/reference/index.html
@@ -0,0 +1,270 @@
+
+
+
+
+
+ FSharp.Formatting (API Reference)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ API Reference
+
+
+ Available Namespaces:
+
+
+
+
+
+ Namespace
+
+
+ Description
+
+
+
+
+
+
+
+ FSharp.Formatting.ApiDocs
+
+
+
+ Functionality relating to generating API documentation
+
+
+
+
+
+ FSharp.Formatting.CSharpFormat
+
+
+
+ Functionality for formatting code in various languages
+
+
+
+
+
+ FSharp.Formatting.CodeFormat
+
+
+
+ Functionality relating to formatting F# scripts and code snippets
+
+
+
+
+
+ FSharp.Formatting.Common
+
+
+
+
+
+
+ FSharp.Formatting.Literate
+
+
+
+ Functionality to support literate programming for F# scripts
+
+
+
+
+
+ FSharp.Formatting.Literate.Evaluation
+
+
+
+ Functionality to support literate evaluation for F# scripts
+
+
+
+
+
+ FSharp.Formatting.Markdown
+
+
+
+ Functionality for processing markdown documents, converting to HTML, LaTeX, ipynb and scripts
+
+
+
+
+
+ FSharp.Formatting.Templating
+
+
+
+ Functionality relating to templating (mostly internal)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/sidebyside/sideextensions.fsx b/sidebyside/sideextensions.fsx
new file mode 100644
index 000000000..2b1b9ca7c
--- /dev/null
+++ b/sidebyside/sideextensions.fsx
@@ -0,0 +1,37 @@
+(**
+# 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.
+
+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.html b/sidebyside/sideextensions.html
new file mode 100644
index 000000000..a00aa0846
--- /dev/null
+++ b/sidebyside/sideextensions.html
@@ -0,0 +1,243 @@
+
+
+
+
+
+ Markdown LaTeX
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ---
+title: Markdown LaTeX
+category: Examples
+categoryindex: 2
+index: 3
+---
+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.
+
+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 `$$$`):
+
+$$$
+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}
+
+Use LaTex escape rule:
+
+- Escape \$ in inline mode: $ \$ $, $ \$var $
+- Other escapes: $ \& \% \$ \# \_ \{ \} $
+- Using < or >: $ x > 1 $, $ y < 1 $, $ x >= 1 $,
+ $ y <= 1 $, $ x = 1 $
+- $ <p>something</p> $
+
+
+
+
+
+
+
+Example: Using the Markdown Extensions for LaTeX
+To use LaTex extension, you need add javascript
+link to MathJax in
+your template.
+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 $$$):
+\[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}\]
+Use LaTex escape rule:
+
+- Escape $ in inline mode: \(\$\), \(\$var\)
+- Other escapes: \(\& \% \$ \# \_ \{ \}\)
+-
+Using < or >: \(x > 1\), \(y < 1\), \(x >= 1\),
+\(y <= 1\), \(x = 1\)
+
+- \(<p>something</p>\)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/sidebyside/sideextensions.ipynb b/sidebyside/sideextensions.ipynb
new file mode 100644
index 000000000..d55942953
--- /dev/null
+++ b/sidebyside/sideextensions.ipynb
@@ -0,0 +1,74 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Example: Using the Markdown Extensions for LaTeX\n",
+ "\n",
+ "To use LaTex extension, you need add javascript\n",
+ "link to [MathJax](http://www.mathjax.org/) in\n",
+ "your template.\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..586407c36
--- /dev/null
+++ b/sidebyside/sideextensions.md
@@ -0,0 +1,35 @@
+# 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.
+
+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..a3b22f4d7
--- /dev/null
+++ b/sidebyside/sideextensions.tex
@@ -0,0 +1,93 @@
+\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.
+
+
+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..1efd3f865
--- /dev/null
+++ b/sidebyside/sidemarkdown.html
@@ -0,0 +1,302 @@
+
+
+
+
+
+ Markdown Content
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ---
+title: Markdown Content
+category: Examples
+categoryindex: 2
+index: 2
+---
+# 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][md] reference.
+
+ [md]: http://daringfireball.net/projects/markdown
+
+
+## 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 `<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!
+ 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`.
+
+
+
+
+
+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.
+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 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 <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!
+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).
+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:
+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..feaf1eb5f
--- /dev/null
+++ b/sidebyside/sidescript.html
@@ -0,0 +1,324 @@
+
+
+
+
+
+ Literate Script
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ (**
+---
+title: Literate Script
+category: Examples
+categoryindex: 2
+index: 1
+---
+# 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][md] features.
+
+ [md]: http://daringfireball.net/projects/markdown
+
+## 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.
+*)
+
+(*** hide ***)
+/// This is a hidden answer
+let hidden = 42
+
+(**
+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`:
+*)
+
+(*** include:later-bit ***)
+
+(**
+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][fs] and add more
+features or report bugs!
+
+ [fs]: https://github.com/fsprojects/FSharp.Formatting
+
+*)
+
+(*** define:later-bit ***)
+let sample = laterFunction () |> printfn "Got: %s"
+
+
+
+
+
+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.
+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 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 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..44a46210d
--- /dev/null
+++ b/styling.fsx
@@ -0,0 +1,165 @@
+(**
+# 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-collection-name-link` | ``
+`fsdocs-license-link` | ``
+`fsdocs-logo-src` | ``
+`fsdocs-logo-link` | ``
+`fsdocs-navbar-position` | `` (`fixed-left` or `fixed-right`)
+`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
+ https://github.com/foo/bar/blob/master/License.txt
+ https://github.com/foo/bar/blob/master/release-notes.md
+ fixed-left
+ true
+ default
+```
+
+As an example, here is [a page with `fsdocs-navbar-position` set to `fixed-right`](templates/leftside/styling.html).
+
+## Customizing via CSS
+
+You can start styling by creating a file `docs/content/fsdocs-custom.css` and adding entries to it. It is loaded by
+the standard template. The CSS classes of generated content are:
+
+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 Id | Content
+:--- | :---
+`#fsdocs-content` | The generated content
+`#fsdocs-searchbox` | The search box
+`#fsdocs-logo` | The logo
+`#fsdocs-nav` | The navigation-bar
+
+
+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-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.
+
+## 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..980f21451
--- /dev/null
+++ b/styling.html
@@ -0,0 +1,412 @@
+
+
+
+
+
+ Customization and Styling
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Customization and Styling
+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 the default template in docs/_template.html
Uses the default styles in docs/content/fsdocs-default.css.
Uses no custom styles in docs/content/fsdocs-custom.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 are particularly related to visual styling:
+
+
+
+Substitution name
Value (if not overriden by --parameters)
+
+
+
+fsdocs-authors
<Authors>
+
+fsdocs-collection-name-link
<FsDocsCollectionNameLink>
+
+fsdocs-license-link
<FsDocsLicenseLink>
+
+fsdocs-logo-src
<FsDocsLogoSource>
+
+fsdocs-logo-link
<FsDocsLogoLink>
+
+fsdocs-navbar-position
<FsDocsNavbarPosition> (fixed-left or fixed-right)
+
+fsdocs-release-notes-link
<FsDocsReleaseNotesLink> else <PackageProjectUrl>/blob/master/RELEASE_NOTES.md
+
+fsdocs-repository-link
<RepositoryUrl>
+
+fsdocs-theme
<FsDocsTheme>, must currently be default
+
+
+
+These basic entry-level styling parameters can be set in the project file or Directory.Build.props.
+For example:
+ <!-- Example ultra-simple styling and generation settings for FsDocs default template-->
+ <PackageLicenseUrl>https://github.com/foo/bar/blob/master/License.txt</PackageLicenseUrl>
+ <PackageProjectUrl>https://foo.github.io/bar/</PackageProjectUrl>
+ <RepositoryUrl>https://github.com/foo/bar/</RepositoryUrl>
+ <FsDocsLogoLink>https://fsharp.org</FsDocsLogoLink>
+ <FsDocsLicenseLink>https://github.com/foo/bar/blob/master/License.txt</FsDocsLicenseLink>
+ <FsDocsReleaseNotesLink>https://github.com/foo/bar/blob/master/release-notes.md</FsDocsReleaseNotesLink>
+ <FsDocsNavbarPosition>fixed-left</FsDocsNavbarPosition>
+ <FsDocsWarnOnMissingDocs>true</FsDocsWarnOnMissingDocs>
+ <FsDocsTheme>default</FsDocsTheme>
+
+As an example, here is a page with fsdocs-navbar-position set to fixed-right.
+Customizing via CSS
+You can start styling by creating a file docs/content/fsdocs-custom.css and adding entries to it. It is loaded by
+the standard template. The CSS classes of generated content are:
+
+
+
+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 Id
Content
+
+
+
+#fsdocs-content
The generated content
+
+#fsdocs-searchbox
The search box
+
+#fsdocs-logo
The logo
+
+#fsdocs-nav
The navigation-bar
+
+
+
+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 <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.
+
+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:
+<li class="nav-header">
+ {{fsdocs-menu-header-content}}
+</li>
+{{fsdocs-menu-items}}
+
+Similarly, to customize the individual menu item list, use file _menu-item_template.html with starting template:
+<li class="nav-item"><a href="{{fsdocs-menu-item-link}}" class="nav-link">{{fsdocs-menu-item-content}}</a></li>
+
+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.
+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.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/styling.ipynb b/styling.ipynb
new file mode 100644
index 000000000..40b8ead1d
--- /dev/null
+++ b/styling.ipynb
@@ -0,0 +1,202 @@
+
+{
+ "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 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 this site.\n",
+ "\n",
+ "* Uses the default template in [docs/_template.html](https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/_template.html)\n",
+ " \n",
+ "\n",
+ "* Uses the default styles 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 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-collection-name-link` | `\u003cFsDocsCollectionNameLink\u003e`\n",
+ "`fsdocs-license-link` | `\u003cFsDocsLicenseLink\u003e`\n",
+ "`fsdocs-logo-src` | `\u003cFsDocsLogoSource\u003e`\n",
+ "`fsdocs-logo-link` | `\u003cFsDocsLogoLink\u003e`\n",
+ "`fsdocs-navbar-position` | `\u003cFsDocsNavbarPosition\u003e` (`fixed-left` or `fixed-right`)\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",
+ " \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",
+ " \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",
+ " \u003cFsDocsNavbarPosition\u003efixed-left\u003c/FsDocsNavbarPosition\u003e\n",
+ " \u003cFsDocsWarnOnMissingDocs\u003etrue\u003c/FsDocsWarnOnMissingDocs\u003e\n",
+ " \u003cFsDocsTheme\u003edefault\u003c/FsDocsTheme\u003e\n",
+ "```\n",
+ "\n",
+ "As an example, here is [a page with `fsdocs-navbar-position` set to `fixed-right`](templates/leftside/styling.html).\n",
+ "\n",
+ "## Customizing via CSS\n",
+ "\n",
+ "You can start styling by creating a file `docs/content/fsdocs-custom.css` and adding entries to it. It is loaded by\n",
+ "the standard template. The CSS classes of generated content are:\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 Id | Content\n",
+ ":--- | :---\n",
+ "`#fsdocs-content` | The generated content\n",
+ "`#fsdocs-searchbox` | The search box\n",
+ "`#fsdocs-logo` | The logo\n",
+ "`#fsdocs-nav` | The navigation-bar\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",
+ "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}}` and `{{fsdocs-menu-item-id}}`, respectively.\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 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..9e25d85ec
--- /dev/null
+++ b/styling.md
@@ -0,0 +1,163 @@
+# 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-collection-name-link` | ``
+`fsdocs-license-link` | ``
+`fsdocs-logo-src` | ``
+`fsdocs-logo-link` | ``
+`fsdocs-navbar-position` | `` (`fixed-left` or `fixed-right`)
+`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
+ https://github.com/foo/bar/blob/master/License.txt
+ https://github.com/foo/bar/blob/master/release-notes.md
+ fixed-left
+ true
+ default
+```
+
+As an example, here is [a page with `fsdocs-navbar-position` set to `fixed-right`](templates/leftside/styling.html).
+
+## Customizing via CSS
+
+You can start styling by creating a file `docs/content/fsdocs-custom.css` and adding entries to it. It is loaded by
+the standard template. The CSS classes of generated content are:
+
+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 Id | Content
+:--- | :---
+`#fsdocs-content` | The generated content
+`#fsdocs-searchbox` | The search box
+`#fsdocs-logo` | The logo
+`#fsdocs-nav` | The navigation-bar
+
+
+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-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.
+
+## 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..dbbcfc2e7
--- /dev/null
+++ b/styling.tex
@@ -0,0 +1,249 @@
+\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-collection-name-link} & \texttt{}\\ \hline
+\texttt{fsdocs-license-link} & \texttt{}\\ \hline
+\texttt{fsdocs-logo-src} & \texttt{}\\ \hline
+\texttt{fsdocs-logo-link} & \texttt{}\\ \hline
+\texttt{fsdocs-navbar-position} & \texttt{} (\texttt{fixed-left} or \texttt{fixed-right})\\ \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
+ https://github.com/foo/bar/blob/master/License.txt
+ https://github.com/foo/bar/blob/master/release-notes.md
+ fixed-left
+ true
+ default
+
+\end{lstlisting}
+
+
+As an example, here is \href{templates/leftside/styling.html}{a page with \texttt{fsdocs-navbar-position} set to \texttt{fixed-right}}.
+\subsection*{Customizing via CSS}
+
+
+
+You can start styling by creating a file \texttt{docs/content/fsdocs-custom.css} and adding entries to it. It is loaded by
+the standard template. The CSS classes of generated content are:
+\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 Id} & \textbf{Content}\\ \hline\hline
+\texttt{\#fsdocs-content} & The generated content\\ \hline
+\texttt{\#fsdocs-searchbox} & The search box\\ \hline
+\texttt{\#fsdocs-logo} & The logo\\ \hline
+\texttt{\#fsdocs-nav} & The navigation-bar\\ \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-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*{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..5047cd35f
--- /dev/null
+++ b/templates/leftside/styling.fsx
@@ -0,0 +1,13 @@
+(**
+# Example: Styling for Right-Side Navigation Bar
+
+The sidebar can be moved to the right by using
+
+`fixed-right`
+
+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..3a27593f8
--- /dev/null
+++ b/templates/leftside/styling.html
@@ -0,0 +1,177 @@
+
+
+
+
+
+ Example: Styling for Right-Side Navigation Bar
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Example: Styling for Right-Side Navigation Bar
+The sidebar can be moved to the right by using
+<FsDocsNavbarPosition>fixed-right<FsDocsNavbarPosition>
+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..09780372a
--- /dev/null
+++ b/templates/leftside/styling.ipynb
@@ -0,0 +1,50 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Example: Styling for Right-Side Navigation Bar\n",
+ "\n",
+ "The sidebar can be moved to the right by using\n",
+ "\n",
+ "`\u003cFsDocsNavbarPosition\u003efixed-right\u003cFsDocsNavbarPosition\u003e`\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..025c1bfbf
--- /dev/null
+++ b/templates/leftside/styling.md
@@ -0,0 +1,11 @@
+# Example: Styling for Right-Side Navigation Bar
+
+The sidebar can be moved to the right by using
+
+`fixed-right`
+
+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..2830c8e95
--- /dev/null
+++ b/templates/leftside/styling.tex
@@ -0,0 +1,63 @@
+\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 using
+
+
+\texttt{fixed-right}
+
+
+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..9bfc34144
--- /dev/null
+++ b/upgrade.html
@@ -0,0 +1,232 @@
+
+
+
+
+
+ Upgrading to fsdocs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Upgrading to fsdocs
+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.
-
+
Run
+dotnet fsdocs watch
+
+and edit and test your docs.
+
+-
+
If using FAKE adjust build.fsx e.g.
+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"
+)
+
+
+-
+
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.
+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.
+
+
+Sample commands:
+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
+
+<manually download and fixup the _template.html>
+
+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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/upgrade.ipynb b/upgrade.ipynb
new file mode 100644
index 000000000..2c33d8be5
--- /dev/null
+++ b/upgrade.ipynb
@@ -0,0 +1,120 @@
+
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+
+ "source": [
+ "# Upgrading to fsdocs\n",
+ "\n",
+ "Here are the typical steps to upgrade a repo based on `ProjectScaffold` to use `fsdocs`\n",
+ "\n",
+ "0 Run\n",
+ " \n",
+ "\n",
+ " [lang=text]\n",
+ " dotnet new tool\n",
+ " dotnet tool install fsdocs-tool\n",
+ " \n",
+ "\n",
+ "1 Delete 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.\n",
+ " \n",
+ "\n",
+ "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\\*`\n",
+ " \n",
+ "\n",
+ "3 Follow the notes in [styling](styling.html) to start to style your site.\n",
+ " \n",
+ "\n",
+ "4 Run\n",
+ " \n",
+ "\n",
+ " [lang=text]\n",
+ " dotnet fsdocs watch\n",
+ " \n",
+ "\n",
+ " and edit and test your docs.\n",
+ " \n",
+ "\n",
+ "5 If using FAKE adjust `build.fsx` e.g.\n",
+ " \n",
+ "\n",
+ " [lang=text]\n",
+ " Target.create \"GenerateDocs\" (fun _ -\u003e\n",
+ " Shell.cleanDir \".fsdocs\"\n",
+ " DotNet.exec id \"fsdocs\" \"build --clean\" |\u003e ignore\n",
+ " )\n",
+ " \n",
+ " Target.create \"ReleaseDocs\" (fun _ -\u003e\n",
+ " Git.Repository.clone \"\" projectRepo \"temp/gh-pages\"\n",
+ " Git.Branches.checkoutBranch \"temp/gh-pages\" \"gh-pages\"\n",
+ " Shell.copyRecursive \"output\" \"temp/gh-pages\" true |\u003e printfn \"%A\"\n",
+ " Git.CommandHelper.runSimpleGitCommand \"temp/gh-pages\" \"add .\" |\u003e printfn \"%s\"\n",
+ " let cmd = sprintf \"\"\"commit -a -m \"Update generated documentation for version %s\"\"\" release.NugetVersion\n",
+ " Git.CommandHelper.runSimpleGitCommand \"temp/gh-pages\" cmd |\u003e printfn \"%s\"\n",
+ " Git.Branches.push \"temp/gh-pages\"\n",
+ " )\n",
+ " \n",
+ "\n",
+ "6 Consider creating `docs\\_template.fsx` and `docs\\_template.ipynb` to enable co-generation of F# scripts and F# notebooks.\n",
+ " \n",
+ "\n",
+ " 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).\n",
+ " \n",
+ "\n",
+ " 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).\n",
+ " \n",
+ "\n",
+ "Sample commands:\n",
+ "\n",
+ " [lang=text]\n",
+ " dotnet tool install fsdocs-tool --local\n",
+ " git add dotnet-tools.json \n",
+ " git rm -fr docs/tools\n",
+ " git mv docs/input/* docs\n",
+ " git mv docs/files/* docs\n",
+ " \n",
+ " \u003cmanually download and fixup the _template.html\u003e\n",
+ "\n",
+ " dotnet fsdocs watch\n",
+ "\n",
+ " touch docs/_template.fsx\n",
+ " touch docs/_template.ipynb\n",
+ " git add docs/_template.fsx\n",
+ " git add docs/_template.ipynb\n",
+ "\n",
+ "Here is an example PR: [https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116](https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116)\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/upgrade.md b/upgrade.md
new file mode 100644
index 000000000..bc67fb405
--- /dev/null
+++ b/upgrade.md
@@ -0,0 +1,81 @@
+# 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.tex b/upgrade.tex
new file mode 100644
index 000000000..c9a6b452b
--- /dev/null
+++ b/upgrade.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*{Upgrading to fsdocs}
+
+
+
+Here are the typical steps to upgrade a repo based on \texttt{ProjectScaffold} to use \texttt{fsdocs}
+\begin{enumerate}
+\item
+
+Run
+\begin{lstlisting}
+dotnet new tool
+dotnet tool install fsdocs-tool
+
+\end{lstlisting}
+
+\item
+
+Delete all of \texttt{docs{\textbackslash}tools} particularly \texttt{docs{\textbackslash}tool{\textbackslash}generate.fsx}. Keep a copy of any templates for reference as you'll have to copy some bits across to the new template.
+
+\item
+
+Put your docs directory so it reflects the final shape of the site. For example move the content of \texttt{docs{\textbackslash}input{\textbackslash}*} and \texttt{docs{\textbackslash}files{\textbackslash}*} directly to \texttt{docs{\textbackslash}*}
+
+\item
+
+Follow the notes in \href{styling.html}{styling} to start to style your site.
+
+\item
+
+Run
+\begin{lstlisting}
+dotnet fsdocs watch
+
+\end{lstlisting}
+
+
+and edit and test your docs.
+
+\item
+
+If using FAKE adjust \texttt{build.fsx} e.g.
+\begin{lstlisting}
+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"
+)
+
+\end{lstlisting}
+
+\item
+
+Consider creating \texttt{docs{\textbackslash}\_template.fsx} and \texttt{docs{\textbackslash}\_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 \href{https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/literate.fsx\#L19}{like this}.
+
+
+Also add load sections to make sure your notebooks and scripts contain the right content to load packages out of repo. For example \href{https://github.com/fsprojects/FSharp.Formatting/blob/master/docs/literate.fsx\#L1}{like this}.
+
+\end{enumerate}
+
+
+
+Sample commands:
+\begin{lstlisting}
+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
+
+\end{lstlisting}
+
+
+Here is an example PR: \href{https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116}{https://github.com/fsprojects/FSharp.Control.AsyncSeq/pull/116}
+
+
+\end{document}
\ No newline at end of file