FSharp.Formatting


FSharp.Formatting

FSharp.CodeFormat Namespace

TypeDescription
CodeFormat

Exposes functionality of the F# code formatter with a nice interface

CodeFormatAgent

Uses agent to handle formatting requests

ErrorKind

Represents a kind of error reported from the F# compiler (warning or error)

FormattedContent

Represents formatted snippets

FormattedSnippet

Represents an indivudal formatted snippet with title

Line

Represents a line of source code as a list of TokenSpan values. This is a single case discriminated union with Line constructor.

Range
Snippet

An F# snippet consists of a snippet title and a list of lines (wrapped in a single case discriminated union with Snippet constructor)

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

Classifies tokens reported by the F# lexer and F# PowerTools (PowerTools provide additional information e.g. whether a variable is mutable, etc.)

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

A type alias representing a list of TokenSpan values

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

FSharp.Collections Namespace

FSharp.Formatting.Common Namespace

TypeDescription
MarkdownRange
ModuleDescription
Log
MarkdownRange

FSharp.Literate Namespace

TypeDescription
CompilerContext

Specifies a context that is passed to functions that need to use the F# compiler

FsiEmbedKind

Represents a kind of thing that can be embedded

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

Provides configuration options for the FsiEvaluator

IFsiEvaluationResult

An interface that represents FSI evaluation result (we make this abstract so that evaluators can store other info)

IFsiEvaluator

Represents an evaluator for F# snippets embedded in code

Literate

This type provides three simple methods for calling the literate programming tool. The ProcessMarkdown and ProcessScriptFile methods process a single Markdown document and F# script, respectively. The ProcessDirectory 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

Specifies visibility of a code snippet. This can be either ordinary visible code, hidden snippet or named snippet with captured output.

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

Represents the source of a literate document. This is esither Markdown (as a string) or parsed F# script file consisting of snippets.

OutputKind

Defines the two possible output types from literate script: HTML and LaTeX.

ProcessingContext

Specifies a context that is passed to functions that generate the output

ModuleDescription
Matching

Provides active patterns for extracting LiterateParagraph values from Markdown documents.

FSharp.Markdown Namespace

TypeDescription
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

A type alias for a list of paragraphs

MarkdownSpan

Represents inline formatting inside a paragraph. This can be literal (with text), various formattings (string, emphasis, etc.), hyperlinks, images, inline maths etc.

MarkdownSpans

A type alias for a list of MarkdownSpan values

MarkdownTableRow

A type alias representing table row as a list of paragraphs

ModuleDescription
Matching

This module provides an easy way of processing Markdown documents. It lets you decompose documents into leafs and nodes with nested paragraphs.

FSharp.MetadataFormat Namespace

TypeDescription
AssemblyGroup
Comment
Html

For use in the tempaltes (lives in namespace FSharp.MetadataFormat)

Member
MemberKind
MemberOrValue
MetadataFormat

This type exposes the functionality for producing documentation from dll files with associated xml files generated by the F# or C# compiler. To generate documentation, use one of the overloades of the Generate method. The overloads have the following optional parameters:

  • outDir - specifies the output directory where documentation should be placed
  • layoutRoots - a list of paths where Razor templates can be found
  • parameters - provides additional parameters to the Razor templates
  • xmlFile - can be used to override the default name of the XML file (by default, we assume the file has the same name as the DLL)
  • markDownComments - specifies if you want to use the Markdown parser for in-code comments. With markDownComments enabled there is no support for <see cref=""> links, so false is recommended for C# assemblies (if not specified, true is used).
  • typeTemplate - the templates to be used for normal types (and C# types) (if not specified, "type.cshtml" is used).
  • moduleTemplate - the templates to be used for modules (if not specified, "module.cshtml" is used).
  • namespaceTemplate - the templates to be used for namespaces (if not specified, "namespaces.cshtml" is used).
  • assemblyReferences - The assemblies to use when compiling Razor templates. Use this parameter if templates fail to compile with mcs on Linux or Mac or if you need additional references in your templates (if not specified, we use the currently loaded assemblies).
  • sourceFolder and sourceRepo - When specified, the documentation generator automatically generates links to GitHub pages for each of the entity.
  • publicOnly - When set to false, the tool will also generate documentation for non-public members
  • libDirs - Use this to specify additional paths where referenced DLL files can be found
  • otherFlags - Additional flags that are passed to the F# compiler (you can use this if you want to specify references explicitly etc.)
  • urlRangeHighlight - A function that can be used to override the default way of generating GitHub links
Module
ModuleInfo
Namespace
Type
TypeInfo
ModuleDescription
Reader
ValueReader

Yaaf.FSharp.Scripting Namespace

TypeDescription
DebugMode
FsiEvaluationException

This exception indicates that an exception happened while compiling or executing given F# code.

FsiExpressionTypeException

Exception for invalid expression types

FsiOptions

See https://msdn.microsoft.com/en-us/library/dd233172.aspx

HandledResult<'a>
IFsiSession

Represents a simple F# interactive session.

InteractionResult
OptimizationType
OutputData
ScriptHost
ModuleDescription
CompilerServiceExtensions
Extensions
Log
Shell
Fork me on GitHub